diff --git a/apps/toolbox/package.json b/apps/toolbox/package.json
index 331ac9ac73..45a7effdd7 100644
--- a/apps/toolbox/package.json
+++ b/apps/toolbox/package.json
@@ -17,6 +17,7 @@
"@nativescript/visionos": "~9.0.0",
"@nativescript/vite": "file:../../dist/packages/vite",
"@nativescript/webpack": "file:../../dist/packages/webpack5",
+ "@nativescript/windows": "0.1.0-alpha.122",
"typescript": "~5.8.0"
}
}
diff --git a/apps/toolbox/src/_app-platform.windows.css b/apps/toolbox/src/_app-platform.windows.css
new file mode 100644
index 0000000000..2a82ae04f6
--- /dev/null
+++ b/apps/toolbox/src/_app-platform.windows.css
@@ -0,0 +1,53 @@
+/* Import theme rules for Windows and include additional core rules so Windows gets the same
+ look as other platforms without modifying the NativeScript runtime. */
+@import '../../../node_modules/nativescript-theme-core/css/core.light.windows.css';
+
+/* Only include the Windows-specific theme file here. Importing iOS/Android theme
+ files in the Windows platform CSS can introduce conflicting rules and
+ unexpected colors; platform-specific CSS should be kept separate. */
+
+/* Fallbacks / platform-specific tweaks for Windows host environments */
+
+/* Ensure pages default to white background like the theme */
+.page, Page {
+ background-color: #fff;
+}
+
+/* Visibility helper used across the theme */
+.invisible {
+ visibility: collapse;
+}
+
+/* Simple shadow/gradient fallbacks — some Windows hosts may not fully support composition */
+.shadow {
+ box-shadow: 0 2 6 rgba(0,0,0,0.2);
+ border-radius: 4;
+}
+.gradient {
+ background: linear-gradient(to bottom, #f12711, #f5af19);
+}
+
+/* Make list items readable on Windows hosts */
+.list-group .list-group-item {
+ padding: 16;
+ color: #212121;
+}
+
+/* TabView / SegmentedBar defaults */
+.tab-view {
+ selected-color: #30bcff;
+ tabs-background-color: #fff;
+}
+.tab-view .tab-view-item {
+ background-color: #fff;
+}
+
+/* Ensure ScrollView / ListView backgrounds don't hide content */
+ScrollView, ListView, Repeater {
+ background-color: transparent;
+}
+
+/* Make sure controls have a sensible default enabled/disabled appearance */
+Button[isEnabled=false], TextField[isEnabled=false], TextView[isEnabled=false] {
+ opacity: 0.6;
+}
diff --git a/apps/toolbox/src/pages/a11y.ts b/apps/toolbox/src/pages/a11y.ts
index 6c82fb442f..f265c833b0 100644
--- a/apps/toolbox/src/pages/a11y.ts
+++ b/apps/toolbox/src/pages/a11y.ts
@@ -17,7 +17,7 @@ export class AccessibilityModel extends Observable {
accessibilityLiveRegions = AccessibilityLiveRegion;
accessibilityRole = AccessibilityRole;
accessibilityState = AccessibilityState;
- largeImageSrc = 'https://i.picsum.photos/id/669/5000/5000.jpg?hmac=VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc';
+ largeImageSrc = 'https://picsum.photos/seed/VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc/5000/5000';
constructor() {
super();
@@ -30,8 +30,8 @@ export class AccessibilityModel extends Observable {
// prettier-ignore
this.notifyPropertyChange('largeImageSrc', checked ?
- 'https://i.picsum.photos/id/669/5000/5000.jpg?hmac=VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc' :
- 'https://i.picsum.photos/id/684/5000/5000.jpg?hmac=loiXO_OQ-y86XY_hc7p3qJdY39fSd9CuDM0iA_--P4Q');
+ 'https://picsum.photos/seed/VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc/5000/5000' :
+ 'https://picsum.photos/seed/loiXO_OQ-y86XY_hc7p3qJdY39fSd9CuDM0iA_--P4Q/5000/5000');
}
openModal() {
diff --git a/apps/toolbox/src/pages/css-playground.ts b/apps/toolbox/src/pages/css-playground.ts
index c2d99fdf4b..a336474873 100644
--- a/apps/toolbox/src/pages/css-playground.ts
+++ b/apps/toolbox/src/pages/css-playground.ts
@@ -36,7 +36,7 @@ export class CssPlaygroundModel extends Observable {
applyCSS(args) {
this.resetCSS();
- addTaggedAdditionalCSS(`#play { ${this.currentCSS}`, CSSTag);
+ addTaggedAdditionalCSS(`#play { ${this.currentCSS} }`, CSSTag);
playLabel._onCssStateChange();
playLabel.requestLayout();
}
diff --git a/apps/toolbox/src/pages/list-page-model-sticky.ts b/apps/toolbox/src/pages/list-page-model-sticky.ts
index cf8b3cb9c1..0ed74e3787 100644
--- a/apps/toolbox/src/pages/list-page-model-sticky.ts
+++ b/apps/toolbox/src/pages/list-page-model-sticky.ts
@@ -1392,7 +1392,18 @@ export class ListPageModelSticky extends Observable {
}
itemLoading(args: EventData): void {
- (args.object as View).backgroundColor = 'transparent';
+ const view = (args as any).view as View;
+ try {
+ const idx = (args as any).index;
+ const section = (args as any).section;
+ const argsBC = (args as any).bindingContext;
+ const obj = (args as any).object;
+ const viewCtor = view && (view as any).constructor ? (view as any).constructor.name : 'unknown';
+ const viewBC = view && (view as any).bindingContext;
+ try { console.log('[ListPageSticky] itemLoading index=', idx, 'section=', section, 'args.bindingContextType=', typeof argsBC, 'args.object=', obj ? (obj.constructor?.name || 'object') : 'null', 'viewType=', viewCtor, 'view.bindingContextType=', typeof viewBC); } catch (_e) {}
+ try { if (viewBC && typeof viewBC === 'object' && (viewBC as any).name) console.log('[ListPageSticky] item name=', (viewBC as any).name); } catch (_e) {}
+ } catch (_e) {}
+ try { view.backgroundColor = 'transparent'; } catch (_e) {}
}
onSearchTextChange(evt: SearchEventData): void {
diff --git a/apps/toolbox/src/pages/list-page.xml b/apps/toolbox/src/pages/list-page.xml
index cce6c49c71..e5e61dc874 100644
--- a/apps/toolbox/src/pages/list-page.xml
+++ b/apps/toolbox/src/pages/list-page.xml
@@ -23,6 +23,9 @@
+
+
+
@@ -47,6 +50,9 @@
+
+
+
diff --git a/apps/toolbox/src/split-view/split-view-primary.ts b/apps/toolbox/src/split-view/split-view-primary.ts
index 3f5748cb28..6bf982c72e 100644
--- a/apps/toolbox/src/split-view/split-view-primary.ts
+++ b/apps/toolbox/src/split-view/split-view-primary.ts
@@ -4,7 +4,9 @@ let page: Page;
export function navigatingTo(args: EventData) {
page = args.object;
- page.bindingContext = new SplitViewPrimaryModel();
+ const model = new SplitViewPrimaryModel();
+ page.bindingContext = model;
+ try { console.log('[Primary] navigatingTo, items.length=', model.items?.length); } catch (_e) {}
}
export class SplitViewPrimaryModel extends Observable {
diff --git a/apps/toolbox/tsconfig.json b/apps/toolbox/tsconfig.json
index 0d0dc494b0..90dddd3baa 100644
--- a/apps/toolbox/tsconfig.json
+++ b/apps/toolbox/tsconfig.json
@@ -5,5 +5,6 @@
"paths": {
"~/*": ["src/*"]
}
- }
+ },
+ "exclude": ["node_modules", "tmp", "platforms", "__tests__", "vite.config.ts"]
}
diff --git a/apps/toolbox/webpack.config.js b/apps/toolbox/webpack.config.js
index c47db7c6f6..5ac42bc263 100644
--- a/apps/toolbox/webpack.config.js
+++ b/apps/toolbox/webpack.config.js
@@ -1,4 +1,5 @@
const webpack = require("@nativescript/webpack");
+const path = require("path");
module.exports = (env) => {
webpack.init(env);
@@ -11,6 +12,11 @@ module.exports = (env) => {
return args
})
+
+ // Stub Windows-unsupported packages
+ if (env.windows) {
+ config.resolve.alias.set('@nativescript/imagepicker', path.resolve(__dirname, 'src/stubs/imagepicker.js'));
+ }
})
return webpack.resolveConfig();
diff --git a/apps/ui/package.json b/apps/ui/package.json
index 0168a45c97..3eddeced4b 100644
--- a/apps/ui/package.json
+++ b/apps/ui/package.json
@@ -15,6 +15,7 @@
"@nativescript/ios": "~9.0.0",
"@nativescript/visionos": "~9.0.0",
"@nativescript/webpack": "file:../../dist/packages/webpack5",
+ "@nativescript/windows": "0.1.0-alpha.122",
"typescript": "~5.8.0"
},
"gitHead": "8ab7726d1ee9991706069c1359c552e67ee0d1a4",
diff --git a/packages/core/animation-frame/animation-native.windows.ts b/packages/core/animation-frame/animation-native.windows.ts
new file mode 100644
index 0000000000..4d13033a2b
--- /dev/null
+++ b/packages/core/animation-frame/animation-native.windows.ts
@@ -0,0 +1,3 @@
+export function getTimeInFrameBase(): number {
+ return Date.now();
+}
diff --git a/packages/core/application-settings/index.windows.ts b/packages/core/application-settings/index.windows.ts
new file mode 100644
index 0000000000..4cba40932a
--- /dev/null
+++ b/packages/core/application-settings/index.windows.ts
@@ -0,0 +1,108 @@
+import * as Common from './application-settings-common';
+
+export function hasKey(key: string): boolean | undefined {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ return localSettings.Values.HasKey(key);
+}
+
+export function getBoolean(key: string, defaultValue?: boolean): boolean | undefined {
+ if (!Common.checkKey(key)) {
+ return undefined;
+ }
+ if (hasKey(key)) {
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ return localSettings.Values[key] as never;
+ }
+
+ return defaultValue;
+}
+
+export function getString(key: string, defaultValue?: string): string | undefined {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ if (hasKey(key)) {
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ return localSettings.Values[key] as never;
+ }
+
+ return defaultValue;
+}
+
+export function getNumber(key: string, defaultValue?: number): number | undefined {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ if (hasKey(key)) {
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ return localSettings.Values[key] as never;
+ }
+
+ return defaultValue;
+}
+
+export function setBoolean(key: string, value: boolean): void {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ if (!Common.ensureValidValue(value, 'boolean')) {
+ return;
+ }
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ localSettings.Values[key] = value;
+}
+
+export function setString(key: string, value: string): void {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ if (!Common.ensureValidValue(value, 'string')) {
+ return;
+ }
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ localSettings.Values[key] = value;
+}
+
+export function setNumber(key: string, value: number): void {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ if (!Common.ensureValidValue(value, 'number')) {
+ return;
+ }
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ localSettings.Values[key] = value;
+}
+
+export function remove(key: string): void {
+ if (!Common.checkKey(key)) {
+ return;
+ }
+ const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+ localSettings.Values.Remove(key);
+}
+
+export function clear(): void {
+ Windows.Storage.ApplicationData.Current.LocalSettings.Values.Clear();
+}
+
+export function flush(): boolean {
+ // no-op since Windows.Storage.ApplicationData is automatically flushed by the system
+ return true;
+}
+
+export function getAllKeys(): Array {
+ const Values = Windows.Storage.ApplicationData.Current.LocalSettings.Values;
+ const first = Values.First();
+ const ret: string[] = [];
+ while (first && first.HasCurrent) {
+ ret.push(first.Current.Key);
+ first.MoveNext();
+ }
+
+ return ret;
+}
diff --git a/packages/core/application/application-common.ts b/packages/core/application/application-common.ts
index 50b27b6f8d..123bef2c07 100644
--- a/packages/core/application/application-common.ts
+++ b/packages/core/application/application-common.ts
@@ -415,6 +415,7 @@ export class ApplicationCommon {
object: this,
ios: this.ios,
android: this.android,
+ windows: this.windows,
...additionalLanchEventData,
};
this.notify(launchArgs);
@@ -746,6 +747,10 @@ export class ApplicationCommon {
return undefined;
}
+ get windows() {
+ return undefined;
+ }
+
get AndroidApplication() {
return this.android;
}
diff --git a/packages/core/application/application.windows.ts b/packages/core/application/application.windows.ts
new file mode 100644
index 0000000000..1520e2993d
--- /dev/null
+++ b/packages/core/application/application.windows.ts
@@ -0,0 +1,181 @@
+import { ApplicationCommon } from './application-common';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import { setAppMainEntry, setToggleApplicationEventListenersCallback, setApplicationPropertiesCallback, setA11yUpdatePropertiesCallback } from './helpers-common';
+import type { View } from '../ui/core/view';
+import { setRootView } from './helpers-common';
+import { CoreTypes } from 'index';
+
+export class WindowsApplication extends ApplicationCommon {
+
+ private _rootView: View;
+
+ getRootView(): View {
+ return this._rootView;
+ }
+
+ run(entry?: string | NavigationEntry): void {
+ if (this.started) {
+ throw new Error('Application is already started.');
+ }
+
+ this.setupLifecycleEvents();
+
+ this.started = true;
+ setAppMainEntry(typeof entry === 'string' ? { moduleName: entry } : entry);
+ this.setWindowContent();
+ }
+
+
+ private setWindowContent(view?: View): void {
+ if (this._rootView) {
+ this._rootView._onRootViewReset();
+ }
+ const rootView = this.createRootView(view, true);
+ if (!rootView) return;
+
+ this._rootView = rootView;
+ setRootView(rootView);
+
+ rootView._setupAsRootView({});
+
+ const win = Windows.UI.Xaml.Window.Current;
+ win.Content = rootView.nativeViewProtected;
+ win.Activate();
+
+ this.initRootView(rootView);
+ rootView.callLoaded();
+ }
+
+ getNativeApplication() {
+ return Windows?.UI?.Xaml?.Application?.Current ?? Windows?.ApplicationModel?.Core?.CoreApplication;
+ }
+
+ protected getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+ try {
+ const displayInfo = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
+ const orientation = displayInfo?.CurrentOrientation;
+ const DisplayOrientations = Windows.Graphics.Display.DisplayOrientations;
+
+ if (orientation === DisplayOrientations.Portrait || orientation === DisplayOrientations.PortraitFlipped) {
+ return 'portrait';
+ }
+
+ if (orientation === DisplayOrientations.Landscape || orientation === DisplayOrientations.LandscapeFlipped) {
+ return 'landscape';
+ }
+ } catch (e) { }
+
+ return 'unknown';
+ }
+
+ protected getSystemAppearance(): 'dark' | 'light' | null {
+ try {
+ const content: any = Windows.UI.Xaml.Window.Current.Content;
+
+ const actualTheme = content?.ActualTheme;
+ const ElementTheme = Windows.UI.Xaml.ElementTheme;
+ if (typeof actualTheme === 'number' && ElementTheme) {
+ if (actualTheme === ElementTheme.Dark) return 'dark';
+ if (actualTheme === ElementTheme.Light) return 'light';
+ }
+
+ const appTheme = Windows.UI.Xaml.Application.Current.RequestedTheme;
+ const ApplicationTheme = Windows.UI.Xaml.ApplicationTheme;
+ if (appTheme === ApplicationTheme.Dark) return 'dark';
+ if (appTheme === ApplicationTheme.Light) return 'light';
+
+ const UISettings = Windows.UI.ViewManagement.UISettings;
+ const ui = new UISettings();
+ const foreground = ui.GetColorValue(Windows.UI.ViewManagement.UIColorType.Foreground);
+ if (!foreground) {
+ return null;
+ }
+
+ // In dark mode Windows uses a light (near-white) foreground color
+ return foreground.R > 128 ? 'dark' : 'light';
+ } catch (e) { }
+
+ return null;
+ }
+
+ protected getLayoutDirection(): CoreTypes.LayoutDirectionType {
+ const content = Windows.UI.Xaml.Window.Current.Content as Windows.UI.Xaml.FrameworkElement | null;
+ if (!content) {
+ return null as never;
+ }
+
+
+ const direction = content.FlowDirection;
+
+ if (direction === Windows.UI.Xaml.FlowDirection.RightToLeft) {
+ return 'rtl';
+ }
+ return 'ltr';
+ }
+
+ private setupLifecycleEvents(): void {
+ const coreApp = Windows.ApplicationModel.Core.CoreApplication;
+
+ if (coreApp) {
+ coreApp.Suspending = (_sender: any, args: any) => this.setSuspended(true, { win: args });
+ coreApp.Resuming = (_sender: any, args: any) => this.setSuspended(false, { win: args });
+ coreApp.EnteredBackground = (_sender: any, args: any) => this.setInBackground(true, { win: args });
+ coreApp.LeavingBackground = (_sender: any, args: any) => this.setInBackground(false, { win: args });
+ coreApp.Exiting = (_sender: any, args: any) => this.notify({ eventName: this.exitEvent, object: this, win: args });
+ coreApp.UnhandledErrorDetected = (_sender: any, args: any) => this.notify({ eventName: this.uncaughtErrorEvent, object: this, win: args });
+ }
+
+ const displayInfo = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
+ const onOrientationChanged = () => {
+ const newValue = this.getOrientation();
+ this.setOrientation(newValue);
+ };
+
+ if (displayInfo && displayInfo.OrientationChanged !== undefined) {
+ displayInfo.OrientationChanged = () => onOrientationChanged();
+ }
+
+ const ui = new Windows.UI.ViewManagement.UISettings();
+ const onColorValuesChanged = () => {
+ const newSys = this.getSystemAppearance();
+ if (newSys !== null) {
+ this.setSystemAppearance(newSys);
+ }
+ };
+
+ if (ui && ui.ColorValuesChanged !== undefined) {
+ ui.ColorValuesChanged = () => onColorValuesChanged();
+ }
+ }
+}
+
+export const Application: WindowsApplication = new WindowsApplication();
+
+function updateAccessibilityProperties(view: any): void {
+ if (!view || !view.nativeViewProtected) {
+ return;
+ }
+
+ // todo
+}
+
+setA11yUpdatePropertiesCallback(updateAccessibilityProperties);
+
+const applicationEvents: string[] = [Application.orientationChangedEvent, Application.systemAppearanceChangedEvent];
+function toggleApplicationEventListeners(toAdd: boolean, callback: (args: any) => void) {
+ for (const eventName of applicationEvents) {
+ if (toAdd) {
+ Application.on(eventName, callback);
+ } else {
+ Application.off(eventName, callback);
+ }
+ }
+}
+setToggleApplicationEventListenersCallback(toggleApplicationEventListeners);
+
+setApplicationPropertiesCallback(() => {
+ return {
+ orientation: Application.orientation(),
+ systemAppearance: Application.systemAppearance(),
+ };
+});
diff --git a/packages/core/application/helpers.windows.ts b/packages/core/application/helpers.windows.ts
new file mode 100644
index 0000000000..db854a7c42
--- /dev/null
+++ b/packages/core/application/helpers.windows.ts
@@ -0,0 +1,14 @@
+// Stubs to avoid bundler warnings on Windows — mirrors helpers.ios.ts shape.
+export const updateContentDescription = (_view: any, _forceUpdate?: boolean): string | null => null;
+
+export function applyContentDescription(_view: any, _forceUpdate?: boolean) {
+ return null;
+}
+
+export function androidGetCurrentActivity() {}
+export function androidGetForegroundActivity() {}
+export function androidSetForegroundActivity(_activity: any): void {}
+export function androidGetStartActivity() {}
+export function androidSetStartActivity(_activity: any): void {}
+
+export function setupAccessibleView(_view: any): void {}
diff --git a/packages/core/application/index.windows.ts b/packages/core/application/index.windows.ts
new file mode 100644
index 0000000000..c912854dcd
--- /dev/null
+++ b/packages/core/application/index.windows.ts
@@ -0,0 +1,2 @@
+export * from './application.windows';
+export * from './application-shims';
diff --git a/packages/core/color/index.d.ts b/packages/core/color/index.d.ts
index 6e2b10a65c..f73a46e2ce 100644
--- a/packages/core/color/index.d.ts
+++ b/packages/core/color/index.d.ts
@@ -52,6 +52,11 @@ export declare class Color {
*/
ios: any /* UIColor */;
+ /**
+ * Gets the Windows-specific Color value representation. This is a read-only property.
+ */
+ windows: any /* Windows.UI.Color */;
+
/**
* Specifies whether this Color is equal to the Color parameter.
* @param value The Color to test.
diff --git a/packages/core/color/index.windows.ts b/packages/core/color/index.windows.ts
new file mode 100644
index 0000000000..3056a1f44a
--- /dev/null
+++ b/packages/core/color/index.windows.ts
@@ -0,0 +1,22 @@
+import { ColorBase } from './color-common';
+import type { IColor } from './color-types';
+
+export class Color extends ColorBase implements IColor {
+ private _windows: Windows.UI.Color | undefined;
+
+ get windows(): Windows.UI.Color {
+ if (!this._windows) {
+ this._windows = Windows.UI.ColorHelper.FromArgb(Math.round(this.a), Math.round(this.r), Math.round(this.g), Math.round(this.b));
+ }
+
+ return this._windows;
+ }
+
+ get windowsArgb(): number {
+ return ((((this.windows.A & 0xff) << 24) | ((this.windows.R & 0xff) << 16) | ((this.windows.G & 0xff) << 8) | (this.windows.B & 0xff)) >>> 0);
+ }
+
+ public static fromWindowsColor(value: Windows.UI.Color): Color {
+ return new Color(Math.round(value.A), Math.round(value.R), Math.round(value.G), Math.round(value.B));
+ }
+}
diff --git a/packages/core/connectivity/index.windows.ts b/packages/core/connectivity/index.windows.ts
new file mode 100644
index 0000000000..7076c332aa
--- /dev/null
+++ b/packages/core/connectivity/index.windows.ts
@@ -0,0 +1,58 @@
+export enum connectionType {
+ none = 0,
+ wifi = 1,
+ mobile = 2,
+ ethernet = 3,
+ bluetooth = 4,
+ vpn = 5,
+}
+
+function parseConnectionProfile(profile?: Windows.Networking.Connectivity.ConnectionProfile) {
+ if (!profile) return connectionType.none;
+
+ const adapter = profile.NetworkAdapter;
+ if (!adapter) return connectionType.none;
+
+ const type = adapter.IanaInterfaceType;
+
+ switch (type) {
+ case 71:
+ return connectionType.wifi;
+ case 6:
+ return connectionType.ethernet;
+ }
+
+ if (profile.IsWwanConnectionProfile) {
+ return connectionType.mobile;
+ }
+
+ if (profile.IsWlanConnectionProfile && profile.GetNetworkConnectivityLevel?.() === 3) {
+ return connectionType.vpn;
+ }
+
+ return connectionType.none;
+}
+
+export function getConnectionType(): number {
+ const profile = Windows.Networking.Connectivity.NetworkInformation.GetInternetConnectionProfile();
+ return parseConnectionProfile(profile);
+}
+
+let callback;
+let delegate;
+
+export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void {
+ const zoneCallback = zonedCallback(connectionTypeChangedCallback);
+ delegate = NSWinRT.asDelegate(() => {
+ const newConnectionType = getConnectionType();
+ zoneCallback(newConnectionType);
+ });
+
+ Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged = delegate;
+}
+
+export function stopMonitoring(): void {
+ Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged = null as never;
+ delegate = null;
+ callback = null;
+}
diff --git a/packages/core/debugger/webinspector-network.windows.ts b/packages/core/debugger/webinspector-network.windows.ts
new file mode 100644
index 0000000000..897a4e2b2a
--- /dev/null
+++ b/packages/core/debugger/webinspector-network.windows.ts
@@ -0,0 +1,359 @@
+import * as inspectorCommands from './InspectorBackendCommands';
+import { File, knownFolders } from '../file-system';
+
+import * as debuggerDomains from '.';
+
+declare let __inspectorSendEvent;
+
+declare let __inspectorTimestamp;
+
+const frameId = 'NativeScriptMainFrameIdentifier';
+const loaderId = 'Loader Identifier';
+
+const resources_datas = [];
+
+const documentTypeByMimeType = {
+ 'text/xml': 'Document',
+ 'text/plain': 'Document',
+ 'text/html': 'Document',
+ 'application/xml': 'Document',
+ 'application/xhtml+xml': 'Document',
+ 'text/css': 'Stylesheet',
+ 'text/javascript': 'Script',
+ 'text/ecmascript': 'Script',
+ 'application/javascript': 'Script',
+ 'application/ecmascript': 'Script',
+ 'application/x-javascript': 'Script',
+ 'application/json': 'Script',
+ 'application/x-json': 'Script',
+ 'text/x-javascript': 'Script',
+ 'text/x-json': 'Script',
+ 'text/typescript': 'Script',
+};
+
+export class Request {
+ private _resourceType: string;
+ private _data: any;
+ private _mimeType: string;
+
+ constructor(
+ private _networkDomainDebugger: NetworkDomainDebugger,
+ private _requestID: string,
+ ) {}
+
+ get mimeType(): string {
+ return this._mimeType;
+ }
+
+ set mimeType(value: string) {
+ if (this._mimeType !== value) {
+ if (!value) {
+ this._mimeType = 'text/plain';
+ this._resourceType = 'Other';
+
+ return;
+ }
+
+ this._mimeType = value;
+
+ let resourceType = 'Other';
+
+ if (this._mimeType in documentTypeByMimeType) {
+ resourceType = documentTypeByMimeType[this._mimeType];
+ }
+
+ if (this._mimeType.indexOf('image/') !== -1) {
+ resourceType = 'Image';
+ }
+
+ if (this._mimeType.indexOf('font/') !== -1) {
+ resourceType = 'Font';
+ }
+
+ this._resourceType = resourceType;
+ }
+ }
+
+ get requestID(): string {
+ return this._requestID;
+ }
+
+ get hasTextContent(): boolean {
+ return ['Document', 'Stylesheet', 'Script', 'XHR'].indexOf(this._resourceType) !== -1;
+ }
+
+ get data(): any {
+ return this._data;
+ }
+
+ set data(value: any) {
+ if (this._data !== value) {
+ this._data = value;
+ }
+ }
+
+ get resourceType() {
+ return this._resourceType;
+ }
+
+ set resourceType(value: string) {
+ if (this._resourceType !== value) {
+ this._resourceType = value;
+ }
+ }
+
+ public responseReceived(response: inspectorCommands.NetworkDomain.Response): void {
+ if (this._networkDomainDebugger.enabled) {
+ this._networkDomainDebugger.events.responseReceived(this.requestID, frameId, loaderId, __inspectorTimestamp(), this.resourceType, response);
+ }
+ }
+
+ public loadingFinished(): void {
+ if (this._networkDomainDebugger.enabled) {
+ this._networkDomainDebugger.events.loadingFinished(this.requestID, __inspectorTimestamp());
+ }
+ }
+
+ public requestWillBeSent(request: inspectorCommands.NetworkDomain.Request): void {
+ if (this._networkDomainDebugger.enabled) {
+ this._networkDomainDebugger.events.requestWillBeSent(this.requestID, frameId, loaderId, request.url, request, __inspectorTimestamp(), { type: 'Script' });
+ }
+ }
+}
+
+function arrayBufferToString(buf: ArrayBuffer | Uint8Array): string {
+ try {
+ if (typeof Buffer !== 'undefined' && Buffer.from) {
+ if (buf instanceof ArrayBuffer) {
+ return Buffer.from(new Uint8Array(buf)).toString('utf8');
+ }
+ return Buffer.from(buf as Uint8Array).toString('utf8');
+ }
+
+ if (typeof TextDecoder !== 'undefined') {
+ return new TextDecoder('utf-8').decode(buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array));
+ }
+
+ // Fallback manual decode
+ const bytes = buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array);
+ let str = '';
+ for (let i = 0; i < bytes.length; i++) {
+ str += String.fromCharCode(bytes[i]);
+ }
+ return str;
+ } catch (e) {
+ return '';
+ }
+}
+
+function arrayBufferToBase64(buf: ArrayBuffer | Uint8Array): string {
+ try {
+ if (typeof Buffer !== 'undefined' && Buffer.from) {
+ if (buf instanceof ArrayBuffer) {
+ return Buffer.from(new Uint8Array(buf)).toString('base64');
+ }
+ return Buffer.from(buf as Uint8Array).toString('base64');
+ }
+
+ // Use Windows API if available
+ try {
+ if (typeof Windows !== 'undefined' && Windows.Security && Windows.Security.Cryptography) {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ if (buf instanceof ArrayBuffer) {
+ writer.WriteBytes(new Uint8Array(buf) as never);
+ } else {
+ writer.WriteBytes(buf as never);
+ }
+ const iBuf = writer.DetachBuffer();
+ return Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(iBuf as any);
+ }
+ } catch (e) {}
+
+ // Fallback to btoa over chunks
+ const bytes = buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array);
+ let binary = '';
+ const chunkSize = 0x8000;
+ for (let i = 0; i < bytes.length; i += chunkSize) {
+ const chunk = bytes.subarray(i, i + chunkSize);
+ binary += String.fromCharCode.apply(null, Array.prototype.slice.call(chunk));
+ }
+ if (typeof btoa !== 'undefined') {
+ return btoa(binary);
+ }
+ return '';
+ } catch (e) {
+ return '';
+ }
+}
+
+@inspectorCommands.DomainDispatcher('Network')
+export class NetworkDomainDebugger implements inspectorCommands.NetworkDomain.NetworkDomainDispatcher {
+ private _enabled: boolean;
+ public events: inspectorCommands.NetworkDomain.NetworkFrontend;
+
+ constructor() {
+ this.events = new inspectorCommands.NetworkDomain.NetworkFrontend();
+
+ // By default start enabled because we can miss the "enable" event when
+ // running with `--debug-brk` -- the frontend will send it before we've been created
+ this.enable();
+ }
+
+ get enabled(): boolean {
+ return this._enabled;
+ }
+
+ /**
+ * Enables network tracking, network events will now be delivered to the client.
+ */
+ enable(): void {
+ if (debuggerDomains.getNetwork()) {
+ throw new Error('One NetworkDomainDebugger may be enabled at a time.');
+ } else {
+ debuggerDomains.setNetwork(this);
+ }
+ this._enabled = true;
+ }
+
+ /**
+ * Disables network tracking, prevents network events from being sent to the client.
+ */
+ disable(): void {
+ if (debuggerDomains.getNetwork() === this) {
+ debuggerDomains.setNetwork(null);
+ }
+ this._enabled = false;
+ }
+
+ /**
+ * Specifies whether to always send extra HTTP headers with the requests from this page.
+ */
+ setExtraHTTPHeaders(params: inspectorCommands.NetworkDomain.SetExtraHTTPHeadersMethodArguments): void {
+ //
+ }
+
+ /**
+ * Returns content served for the given request.
+ */
+ getResponseBody(params: inspectorCommands.NetworkDomain.GetResponseBodyMethodArguments): { body: string; base64Encoded: boolean } {
+ const resource_data = resources_datas[params.requestId];
+ if (!resource_data) {
+ return { body: '', base64Encoded: false };
+ }
+
+ // Try to handle multiple data shapes across platforms/runtimes
+ // Prefer text decoding for text-like resources
+ try {
+ if (resource_data.hasTextContent) {
+ if (typeof resource_data.data === 'string') {
+ return { body: resource_data.data, base64Encoded: false };
+ }
+ if (resource_data.data instanceof ArrayBuffer || resource_data.data instanceof Uint8Array) {
+ return { body: arrayBufferToString(resource_data.data), base64Encoded: false };
+ }
+ // Fallback: attempt toString
+ return { body: resource_data.data?.toString() ?? '', base64Encoded: false };
+ } else {
+ if (resource_data.data instanceof ArrayBuffer || resource_data.data instanceof Uint8Array) {
+ return { body: arrayBufferToBase64(resource_data.data), base64Encoded: true };
+ }
+
+ // If underlying platform produced a Windows IBuffer or similar, try Windows API
+ try {
+ if (typeof Windows !== 'undefined' && Windows.Security && Windows.Security.Cryptography && resource_data.data && (resource_data.data as any).Length !== undefined) {
+ // resource_data.data is likely an IBuffer-like object
+ return { body: Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(resource_data.data as any), base64Encoded: true };
+ }
+ } catch (e) {}
+
+ // Last-ditch: attempt Buffer or btoa
+ if (typeof Buffer !== 'undefined' && Buffer.from) {
+ try {
+ return { body: Buffer.from(resource_data.data as any).toString('base64'), base64Encoded: true };
+ } catch (e) {}
+ }
+ // fallback empty
+ return { body: '', base64Encoded: true };
+ }
+ } catch (e) {
+ return { body: '', base64Encoded: !resource_data.hasTextContent };
+ }
+ }
+
+ /**
+ * Tells whether clearing browser cache is supported.
+ */
+ canClearBrowserCache(): { result: boolean } {
+ return {
+ result: false,
+ };
+ }
+
+ /**
+ * Clears browser cache.
+ */
+ clearBrowserCache(): void {
+ //
+ }
+
+ /**
+ * Tells whether clearing browser cookies is supported.
+ */
+ canClearBrowserCookies(): { result: boolean } {
+ return {
+ result: false,
+ };
+ }
+
+ /**
+ * Clears browser cookies.
+ */
+ clearBrowserCookies(): void {
+ //
+ }
+
+ /**
+ * Toggles ignoring cache for each request. If true, cache will not be used.
+ */
+ setCacheDisabled(params: inspectorCommands.NetworkDomain.SetCacheDisabledMethodArguments): void {
+ //
+ }
+
+ /**
+ * Loads a resource in the context of a frame on the inspected page without cross origin checks.
+ */
+ loadResource(params: inspectorCommands.NetworkDomain.LoadResourceMethodArguments): { content: string; mimeType: string; status: number } {
+ const appPath = knownFolders.currentApp().path;
+ // Normalize incoming url like: file:// or file:///app/...
+ let rel = params.url.replace(/^file:\/\/?/, '');
+ if (rel.startsWith('app/')) {
+ rel = rel.substr(4);
+ }
+ const pathUrl = `${appPath}/${rel}`;
+ const file = File.exists(pathUrl) ? File.fromPath(pathUrl) : undefined;
+ let content = '';
+ try {
+ if (file) {
+ // Prefer text read for resources; binary consumers will request via getResponseBody
+ content = file.readTextSync();
+ }
+ } catch (e) {
+ content = '';
+ }
+
+ return {
+ content: content.toString(),
+ mimeType: 'application/octet-stream',
+ status: 200,
+ };
+ }
+
+ public static idSequence = 0;
+ create(): Request {
+ const id = (++NetworkDomainDebugger.idSequence).toString();
+ const resourceData = new Request(this, id);
+ resources_datas[id] = resourceData;
+
+ return resourceData;
+ }
+}
diff --git a/packages/core/file-system/file-system-access.windows.ts b/packages/core/file-system/file-system-access.windows.ts
new file mode 100644
index 0000000000..52ea728552
--- /dev/null
+++ b/packages/core/file-system/file-system-access.windows.ts
@@ -0,0 +1,456 @@
+import { encoding as textEncoding } from '../text';
+
+function getPathSep(): string {
+ return '\\';
+}
+
+function getFileName(path: string): string {
+ const sep = path.lastIndexOf('\\') !== -1 ? '\\' : '/';
+ return path.substring(path.lastIndexOf(sep) + 1);
+}
+
+function getExtension(name: string): string {
+ const dot = name.lastIndexOf('.');
+ return dot >= 0 ? name.substring(dot) : '';
+}
+
+export class FileSystemAccess {
+ public getLastModified(path: string): Date {
+ try {
+ const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+ return file?.DateCreated ? new Date(file.DateCreated) : new Date();
+ } catch {
+ return new Date();
+ }
+ }
+
+ public getFileSize(path: string): number {
+ try {
+ const props = (Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any)?.GetBasicPropertiesAsync?.();
+ return props?.Size ?? 0;
+ } catch {
+ return 0;
+ }
+ }
+
+ public getParent(path: string, onError?: (error: any) => any): { path: string; name: string } {
+ try {
+ const sep = path.lastIndexOf('\\') !== -1 ? '\\' : '/';
+ const parentPath = path.substring(0, path.lastIndexOf(sep)) || path;
+ const name = getFileName(parentPath);
+ return { path: parentPath, name };
+ } catch (ex) {
+ if (onError) onError(ex);
+ return undefined;
+ }
+ }
+
+ public getFile(path: string, onError?: (error: any) => any): { path: string; name: string; extension: string } {
+ try {
+ if (!this.fileExists(path)) {
+ this._ensureParentDir(path);
+ Windows.Storage.PathIO.WriteTextAsync(path, '');
+ }
+ const name = getFileName(path);
+ return { path, name, extension: getExtension(name) };
+ } catch (ex) {
+ if (onError) onError(ex);
+ return undefined;
+ }
+ }
+
+ public getFolder(path: string, onError?: (error: any) => any): { path: string; name: string } {
+ try {
+ if (!this.folderExists(path)) {
+ Windows.Storage.StorageFolder.GetFolderFromPathAsync(path);
+ }
+ return { path, name: getFileName(path) };
+ } catch (ex) {
+ if (onError) onError(ex);
+ return undefined;
+ }
+ }
+
+ public getExistingFolder(path: string, onError?: (error: any) => any): { path: string; name: string } {
+ try {
+ if (this.folderExists(path)) {
+ return { path, name: getFileName(path) };
+ }
+ return undefined;
+ } catch (ex) {
+ if (onError) onError(ex);
+ return undefined;
+ }
+ }
+
+ public eachEntity(path: string, onEntity: (file: { path: string; name: string; extension: string }) => any, onError?: (error: any) => any) {
+ if (!onEntity) return;
+ this._enumEntities(path, onEntity, onError);
+ }
+
+ public getEntities(path: string, onError?: (error: any) => any): Array<{ path: string; name: string; extension: string }> {
+ const results: Array<{ path: string; name: string; extension: string }> = [];
+ let errored = false;
+ this._enumEntities(
+ path,
+ (entity) => {
+ results.push(entity);
+ return true;
+ },
+ (err) => {
+ if (onError) onError(err);
+ errored = true;
+ },
+ );
+ return errored ? null : results;
+ }
+
+ public fileExists(path: string): boolean {
+ try {
+ Windows.Storage.StorageFile.GetFileFromPathAsync(path);
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ public folderExists(path: string): boolean {
+ try {
+ Windows.Storage.StorageFolder.GetFolderFromPathAsync(path);
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ public deleteFile(path: string, onError?: (error: any) => any) {
+ try {
+ const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+ file?.DeleteAsync?.();
+ } catch (ex) {
+ if (onError) onError(ex);
+ }
+ }
+
+ public deleteFolder(path: string, onError?: (error: any) => any) {
+ try {
+ const folder = Windows.Storage.StorageFolder.GetFolderFromPathAsync(path) as any;
+ folder?.DeleteAsync?.();
+ } catch (ex) {
+ if (onError) onError(ex);
+ }
+ }
+
+ public emptyFolder(path: string, onError?: (error: any) => any) {
+ const entities = this.getEntities(path, onError);
+ if (!entities) return;
+ for (const entity of entities) {
+ try {
+ this.deleteFile(entity.path, onError);
+ } catch (ex) {
+ if (onError) onError(ex);
+ return;
+ }
+ }
+ }
+
+ public rename(path: string, newPath: string, onError?: (error: any) => any) {
+ try {
+ const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+ const newName = getFileName(newPath);
+ file?.RenameAsync?.(newName);
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to rename '${path}' to '${newPath}': ${ex}`));
+ }
+ }
+
+ public readText = this.readTextSync.bind(this);
+
+ public readTextAsync(path: string, encoding?: any): Promise {
+ const enc = encoding ?? textEncoding.UTF_8;
+ return new Promise((resolve, reject) => {
+ try {
+ (Windows.Storage.PathIO.ReadTextAsync(path) as any).then(resolve, reject);
+ } catch (ex) {
+ reject(new Error(`Failed to read file at path '${path}': ${ex}`));
+ }
+ });
+ }
+
+ public readTextSync(path: string, onError?: (error: any) => any, _encoding?: any): string {
+ try {
+ let result: string;
+ (Windows.Storage.PathIO.ReadTextAsync(path) as any).done((text: string) => {
+ result = text;
+ });
+ return result ?? '';
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to read file at path '${path}': ${ex}`));
+ return undefined;
+ }
+ }
+
+ public writeText = this.writeTextSync.bind(this);
+
+ public writeTextAsync(path: string, content: string, _encoding?: any): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ (Windows.Storage.PathIO.WriteTextAsync(path, content) as any).then(resolve, reject);
+ } catch (ex) {
+ reject(new Error(`Failed to write file at path '${path}': ${ex}`));
+ }
+ });
+ }
+
+ public writeTextSync(path: string, content: string, onError?: (error: any) => any, _encoding?: any) {
+ try {
+ (Windows.Storage.PathIO.WriteTextAsync(path, content) as any).done();
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to write file at path '${path}': ${ex}`));
+ }
+ }
+
+ public appendText = this.appendTextSync.bind(this);
+
+ public appendTextAsync(path: string, content: string, _encoding?: any): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ (Windows.Storage.PathIO.AppendTextAsync(path, content) as any).then(resolve, reject);
+ } catch (ex) {
+ reject(new Error(`Failed to append to file at path '${path}': ${ex}`));
+ }
+ });
+ }
+
+ public appendTextSync(path: string, content: string, onError?: (error: any) => any, _encoding?: any) {
+ try {
+ (Windows.Storage.PathIO.AppendTextAsync(path, content) as any).done();
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to append to file at path '${path}': ${ex}`));
+ }
+ }
+
+ public readBuffer = this.readBufferSync.bind(this);
+
+ public readBufferAsync(path: string): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ (Windows.Storage.PathIO.ReadBufferAsync(path) as any).then((buffer: any) => {
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ const bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes);
+ resolve(bytes.buffer);
+ }, reject);
+ } catch (ex) {
+ reject(new Error(`Failed to read buffer at path '${path}': ${ex}`));
+ }
+ });
+ }
+
+ public readBufferSync(path: string, onError?: (error: any) => any): ArrayBuffer {
+ try {
+ let result: ArrayBuffer;
+ (Windows.Storage.PathIO.ReadBufferAsync(path) as any).done((buffer: any) => {
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ const bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes);
+ result = bytes.buffer;
+ });
+ return result;
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to read buffer at path '${path}': ${ex}`));
+ return undefined;
+ }
+ }
+
+ public writeBuffer = this.writeBufferSync.bind(this);
+
+ public writeBufferAsync(path: string, content: ArrayBuffer): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(new Uint8Array(content));
+ const buf = writer.DetachBuffer();
+ (Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).then(resolve, reject);
+ } catch (ex) {
+ reject(new Error(`Failed to write buffer at path '${path}': ${ex}`));
+ }
+ });
+ }
+
+ public writeBufferSync(path: string, content: ArrayBuffer, onError?: (error: any) => any) {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(new Uint8Array(content));
+ const buf = writer.DetachBuffer();
+ (Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).done();
+ } catch (ex) {
+ if (onError) onError(new Error(`Failed to write buffer at path '${path}': ${ex}`));
+ }
+ }
+
+ public read = this.readSync.bind(this);
+
+ public readAsync(path: string): Promise {
+ return this.readBufferAsync(path);
+ }
+
+ public readSync(path: string, onError?: (error: any) => any): any {
+ return this.readBufferSync(path, onError);
+ }
+
+ public write = this.writeSync.bind(this);
+
+ public writeAsync(path: string, content: any): Promise {
+ return this.writeBufferAsync(path, content);
+ }
+
+ public writeSync(path: string, content: any, onError?: (error: any) => any) {
+ return this.writeBufferSync(path, content, onError);
+ }
+
+ public append = this.appendSync.bind(this);
+
+ public appendAsync(path: string, content: any): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(new Uint8Array(content));
+ const buf = writer.DetachBuffer();
+ (Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).then(resolve, reject);
+ } catch (ex) {
+ reject(ex);
+ }
+ });
+ }
+
+ public appendSync(path: string, content: any, onError?: (error: any) => any) {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(new Uint8Array(content));
+ const buf = writer.DetachBuffer();
+ (Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).done();
+ } catch (ex) {
+ if (onError) onError(ex);
+ }
+ }
+
+ public copy = this.copySync.bind(this);
+
+ public copySync(src: string, dest: string, onError?: (error: any) => any): boolean {
+ try {
+ const srcFile = Windows.Storage.StorageFile.GetFileFromPathAsync(src) as any;
+ const destParent = this.getParent(dest)?.path;
+ const destFolder = Windows.Storage.StorageFolder.GetFolderFromPathAsync(destParent) as any;
+ const destName = getFileName(dest);
+ srcFile?.CopyAsync?.(destFolder, destName, Windows.Storage.NameCollisionOption.ReplaceExisting);
+ return true;
+ } catch (ex) {
+ if (onError) onError(ex);
+ return false;
+ }
+ }
+
+ public copyAsync(src: string, dest: string): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ (Windows.Storage.StorageFile.GetFileFromPathAsync(src) as any).then((srcFile: any) => {
+ const destParent = this.getParent(dest)?.path;
+ (Windows.Storage.StorageFolder.GetFolderFromPathAsync(destParent) as any).then((destFolder: any) => {
+ const destName = getFileName(dest);
+ srcFile.CopyAsync(destFolder, destName, Windows.Storage.NameCollisionOption.ReplaceExisting).then(() => resolve(true), reject);
+ }, reject);
+ }, reject);
+ } catch (ex) {
+ reject(ex);
+ }
+ });
+ }
+
+ public getPathSeparator(): string {
+ return getPathSep();
+ }
+
+ public normalizePath(path: string): string {
+ return path.replace(/\//g, '\\');
+ }
+
+ public joinPath(left: string, right: string): string {
+ const l = left.endsWith('\\') || left.endsWith('/') ? left.slice(0, -1) : left;
+ const r = right.startsWith('\\') || right.startsWith('/') ? right.slice(1) : right;
+ return `${l}\\${r}`;
+ }
+
+ public joinPaths(...paths: string[]): string {
+ return paths.reduce((acc, p) => this.joinPath(acc, p));
+ }
+
+ public getDocumentsFolderPath(): string {
+ try {
+ return Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+ } catch {
+ return '';
+ }
+ }
+
+ public getExternalDocumentsFolderPath(): string {
+ return this.getDocumentsFolderPath();
+ }
+
+ public getTempFolderPath(): string {
+ try {
+ return Windows.Storage.ApplicationData.Current.TemporaryFolder.Path;
+ } catch {
+ return '';
+ }
+ }
+
+ public getCurrentAppPath(): string {
+ try {
+ return Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
+ } catch {
+ if (!global.__dirname) {
+ global.__dirname = typeof __dirname !== 'undefined' ? __dirname : '';
+ }
+ return global.__dirname;
+ }
+ }
+
+ public getLogicalRootPath(): string {
+ return this.getCurrentAppPath();
+ }
+
+ private _ensureParentDir(path: string): void {
+ const parent = this.getParent(path)?.path;
+ if (parent && !this.folderExists(parent)) {
+ try {
+ const parts = parent.split('\\');
+ let current = parts[0];
+ for (let i = 1; i < parts.length; i++) {
+ current += '\\' + parts[i];
+ if (!this.folderExists(current)) {
+ (Windows.Storage.StorageFolder.GetFolderFromPathAsync(current) as any);
+ }
+ }
+ } catch {}
+ }
+ }
+
+ private _enumEntities(path: string, onEntity: (file: { path: string; name: string; extension: string }) => any, onError?: (error: any) => any) {
+ try {
+ (Windows.Storage.StorageFolder.GetFolderFromPathAsync(path) as any).done((folder: any) => {
+ (folder.GetItemsAsync() as any).done((items: any) => {
+ for (let i = 0; i < items.Size; i++) {
+ const item = items.GetAt(i);
+ const name = item.Name;
+ const itemPath = item.Path;
+ const cont = onEntity({ path: itemPath, name, extension: getExtension(name) });
+ if (cont === false) break;
+ }
+ });
+ });
+ } catch (ex) {
+ if (onError) onError(ex);
+ }
+ }
+}
diff --git a/packages/core/fps-meter/fps-native.windows.ts b/packages/core/fps-meter/fps-native.windows.ts
new file mode 100644
index 0000000000..69b6dcf22a
--- /dev/null
+++ b/packages/core/fps-meter/fps-native.windows.ts
@@ -0,0 +1,44 @@
+export class FPSCallback {
+ public running: boolean = false;
+ private onFrame: (currentTimeMillis: number) => void;
+ private _timer: any = null;
+
+ constructor(onFrame: (currentTimeMillis: number) => void) {
+ this.onFrame = onFrame;
+ }
+
+ public start() {
+ if (this.running) {
+ return;
+ }
+ this.running = true;
+
+ try {
+ const timer = new Windows.UI.Xaml.DispatcherTimer();
+ const interval = { Duration: 160000 }; // 16ms in 100-nanosecond ticks
+ timer.Interval = interval as any;
+ timer.Tick = NSWinRT.asDelegate(() => {
+ if (this.running) {
+ this.onFrame(Date.now());
+ }
+ });
+ timer.Start();
+ this._timer = timer;
+ } catch {
+ // Fallback: no-op if WinRT not available
+ }
+ }
+
+ public stop() {
+ if (!this.running) {
+ return;
+ }
+ this.running = false;
+ if (this._timer) {
+ try {
+ this._timer.Stop();
+ } catch {}
+ this._timer = null;
+ }
+ }
+}
diff --git a/packages/core/global-types.d.ts b/packages/core/global-types.d.ts
index 78ca864489..d003c79cec 100644
--- a/packages/core/global-types.d.ts
+++ b/packages/core/global-types.d.ts
@@ -135,6 +135,7 @@ declare const __ANDROID__: boolean;
declare const __IOS__: boolean;
declare const __VISIONOS__: boolean;
declare const __APPLE__: boolean;
+declare const __WINDOWS__: boolean;
declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): number;
declare function clearTimeout(timeoutId: number): void;
diff --git a/packages/core/http/http-request-internal/index.windows.ts b/packages/core/http/http-request-internal/index.windows.ts
new file mode 100644
index 0000000000..53be0db452
--- /dev/null
+++ b/packages/core/http/http-request-internal/index.windows.ts
@@ -0,0 +1,145 @@
+import type { HttpRequestOptions, HttpResponse, Headers } from '../http-interfaces';
+import { HttpResponseEncoding } from '../http-interfaces';
+import { BaseHttpContent } from '.';
+import { addHeader } from './http-request-internal-common';
+import { isMainThread, dispatchToMainThread } from '../../utils/mainthread-helper';
+export { addHeader } from './http-request-internal-common';
+
+export function requestInternal(options: HttpRequestOptions, contentHandler?: T): Promise> {
+ return new Promise>((resolve, reject) => {
+ if (!options.url) {
+ reject(new Error('Request url was empty.'));
+ return;
+ }
+
+ try {
+ const httpClient = new Windows.Web.Http.HttpClient();
+ const uri = new Windows.Foundation.Uri(options.url.trim());
+ const method = new Windows.Web.Http.HttpMethod(options.method || 'GET');
+ const requestMessage = new Windows.Web.Http.HttpRequestMessage(method, uri);
+
+ if (options.headers) {
+ for (const key in options.headers) {
+ try {
+ requestMessage.Headers.TryAppendWithoutValidation(key, options.headers[key] + '');
+ } catch { }
+ }
+ }
+
+ if (options.content) {
+ if (typeof options.content === 'string') {
+ requestMessage.Content = new Windows.Web.Http.HttpStringContent(options.content);
+ } else if (options.content instanceof FormData) {
+ requestMessage.Content = new Windows.Web.Http.HttpStringContent(options.content.toString());
+ } else if (options.content instanceof ArrayBuffer) {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(new Uint8Array(options.content as ArrayBuffer) as never);
+ requestMessage.Content = new Windows.Web.Http.HttpBufferContent(writer.DetachBuffer());
+ }
+ }
+
+
+ NSWinRT.toPromise(httpClient.SendRequestAsync(requestMessage)).then(
+ (response: Windows.Web.Http.HttpResponseMessage) => {
+ const statusCode: number = response.StatusCode as unknown as number;
+ const headers: Headers = {};
+
+ try {
+ const Headers = response.Headers;
+ const first = Headers.First();
+ while (first && first.HasCurrent) {
+ const header = first.Current;
+ addHeader(headers, header.Key, header.Value);
+ first.MoveNext();
+ }
+ } catch { }
+ try {
+ const Headers = response.Content.Headers;
+ const first = Headers.First();
+ while (first && first.HasCurrent) {
+ const header = first.Current;
+ addHeader(headers, header.Key, header.Value);
+ first.MoveNext();
+ }
+ } catch { }
+
+ NSWinRT.toPromise(response.Content.ReadAsBufferAsync()).then(
+ (buffer: Windows.Storage.Streams.IBuffer) => {
+ let bytes: Uint8Array;
+ try {
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes as never);
+ } catch {
+ bytes = new Uint8Array(0);
+ }
+
+ const rawBuffer = bytes.buffer as ArrayBuffer;
+
+ const content = {
+ raw: rawBuffer,
+ requestURL: options.url,
+ toNativeImage: (): Promise => {
+ return new Promise((resolve, reject) => {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(bytes as never);
+ const freshBuffer = writer.DetachBuffer();
+ const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+ NSWinRT.toPromise((stream as any).WriteAsync(freshBuffer)).then(() => {
+ const createBitmap = () => {
+ try {
+ (stream as any).Seek(0);
+ const bmp = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
+ NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+ () => { stream.Close(); resolve(bmp); },
+ reject
+ );
+ } catch (e) { reject(e); }
+ };
+ if (isMainThread()) {
+ createBitmap();
+ } else {
+ dispatchToMainThread(createBitmap);
+ }
+ }, reject);
+ } catch (e) { reject(e); }
+ });
+ },
+ toNativeString: (encoding?: HttpResponseEncoding) => {
+ return BufferToString(buffer, encoding);
+ },
+ };
+
+ if (contentHandler != null && typeof contentHandler === 'object' && !Array.isArray(contentHandler)) {
+ Object.assign(content, contentHandler);
+ }
+
+ resolve({
+ content: content as BaseHttpContent & T,
+ statusCode,
+ headers,
+ });
+ },
+ (err: any) => reject(new Error(err?.message ?? String(err)))
+ );
+ },
+ ).catch((err: any) => {
+ reject(new Error(err?.message ?? String(err)));
+ });
+ } catch (ex) {
+ reject(ex);
+ }
+ });
+}
+
+
+function BufferToString(buffer: Windows.Storage.Streams.IBuffer, encoding?: HttpResponseEncoding): string {
+ let encodingType = Windows.Security.Cryptography.BinaryStringEncoding.Utf8;
+ if (encoding === HttpResponseEncoding.GBK) {
+ encodingType = Windows.Security.Cryptography.BinaryStringEncoding.Utf8; // Windows does not support GBK, fallback to UTF-8
+ }
+ return Windows.Security.Cryptography.CryptographicBuffer.ConvertBinaryToString(
+ encodingType,
+ buffer);
+}
\ No newline at end of file
diff --git a/packages/core/http/http-request/index.windows.ts b/packages/core/http/http-request/index.windows.ts
new file mode 100644
index 0000000000..334855d157
--- /dev/null
+++ b/packages/core/http/http-request/index.windows.ts
@@ -0,0 +1,44 @@
+import type { HttpResponse, HttpRequestOptions, HttpContentHandler } from '../../http';
+import { ImageSource } from '../../image-source';
+import { File } from '../../file-system';
+import type { HttpResponseEncoding } from '../http-interfaces';
+import { BaseHttpContent, requestInternal } from '../http-request-internal';
+import { getFilenameFromUrl, parseJSON } from './http-request-common';
+
+const contentHandler: HttpContentHandler = {
+ toArrayBuffer(this: BaseHttpContent) {
+ if (this.raw instanceof ArrayBuffer) {
+ return this.raw;
+ }
+ if (this.raw instanceof Uint8Array) {
+ return this.raw.buffer;
+ }
+ return new ArrayBuffer(0);
+ },
+ toString(this: BaseHttpContent, _encoding?: HttpResponseEncoding) {
+ const str = this.toNativeString(_encoding);
+ if (typeof str === 'string') {
+ return str;
+ }
+ throw new Error('Response content may not be converted to string');
+ },
+ toJSON(this: BaseHttpContent, encoding?: HttpResponseEncoding) {
+ return parseJSON(this.toNativeString(encoding));
+ },
+ toImage(this: BaseHttpContent) {
+ return this.toNativeImage().then((value) => new ImageSource(value));
+ },
+ toFile(this: BaseHttpContent, destinationFilePath?: string) {
+ if (!destinationFilePath) {
+ destinationFilePath = getFilenameFromUrl(this.requestURL);
+ }
+ const file = File.fromPath(destinationFilePath);
+ const data = this.raw instanceof ArrayBuffer ? this.raw : (this.raw instanceof Uint8Array ? this.raw.buffer : new ArrayBuffer(0));
+ file.writeSync(data);
+ return file;
+ },
+};
+
+export function request(options: HttpRequestOptions): Promise {
+ return requestInternal(options, contentHandler);
+}
diff --git a/packages/core/image-asset/index.windows.ts b/packages/core/image-asset/index.windows.ts
new file mode 100644
index 0000000000..fd44202d9c
--- /dev/null
+++ b/packages/core/image-asset/index.windows.ts
@@ -0,0 +1,46 @@
+import { ImageAssetBase, getRequestedImageSize } from './image-asset-common';
+import { path as fsPath, knownFolders } from '../file-system';
+
+export * from './image-asset-common';
+
+export class ImageAsset extends ImageAssetBase {
+ private _windows: any;
+
+ constructor(asset: string | any) {
+ super();
+ if (typeof asset === 'string') {
+ if (asset.indexOf('~/') === 0) {
+ asset = fsPath.join(knownFolders.currentApp().path, asset.replace('~/', ''));
+ }
+ this._windows = asset;
+ } else {
+ this._windows = asset;
+ }
+ }
+
+ get windows(): any {
+ return this._windows;
+ }
+
+ set windows(value: any) {
+ this._windows = value;
+ }
+
+ public getImageAsync(callback: (image: any, error: any) => void) {
+ try {
+ if (typeof this._windows === 'string') {
+ const path = this._windows;
+ (Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any).then(
+ (file: any) => {
+ callback(file, null);
+ },
+ (err: any) => callback(null, err),
+ );
+ } else {
+ callback(this._windows, null);
+ }
+ } catch (ex) {
+ callback(null, ex);
+ }
+ }
+}
diff --git a/packages/core/image-source/index.d.ts b/packages/core/image-source/index.d.ts
index 95d086d474..86157737e2 100644
--- a/packages/core/image-source/index.d.ts
+++ b/packages/core/image-source/index.d.ts
@@ -31,6 +31,11 @@ export class ImageSource {
*/
android: any /* android.graphics.Bitmap */;
+ /**
+ * The Windows-specific [image](https://learn.microsoft.com/en-us/uwp/api/windows.ui.xaml.media.imagesource) instance. Will be undefined when running on iOS or Android.
+ */
+ windows: any /* Windows.UI.Xaml.Media.ImageSource */;
+
/**
* Loads this instance from the specified asset asynchronously.
* @param asset The ImageAsset instance used to create ImageSource.
diff --git a/packages/core/image-source/index.windows.ts b/packages/core/image-source/index.windows.ts
new file mode 100644
index 0000000000..28f845d5b4
--- /dev/null
+++ b/packages/core/image-source/index.windows.ts
@@ -0,0 +1,400 @@
+import type { ImageSource as ImageSourceDefinition } from '.';
+import { ImageAsset } from '../image-asset';
+import { path as fsPath, knownFolders } from '../file-system';
+import { isFileOrResourcePath } from '../utils';
+import { Trace } from '../trace';
+import { isMainThread, dispatchToMainThread } from '../utils/mainthread-helper';
+import { requestInternal as httpRequest } from '../http/http-request-internal';
+export { isFileOrResourcePath };
+
+// Cached constants for resource name handling
+const RES_PREFIX = 'res://';
+const LEADING_SLASHES_RE = /^[\\/]+/;
+const BACKSLASH_RE = /\\/g;
+
+function makeBitmapImage() {
+ return new Windows.UI.Xaml.Media.Imaging.BitmapImage();
+}
+
+function bitmapFromUriAsync(uriStr: string): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ const bmp = makeBitmapImage();
+ const onOpened = () => {
+ resolve(bmp);
+ };
+ const onFailed = (s: any, e: any) => {
+ reject(e || new Error('Image load failed'));
+ };
+ bmp.ImageOpened = onOpened;
+ bmp.ImageFailed = onFailed;
+ bmp.UriSource = new Windows.Foundation.Uri(uriStr);
+ } catch (err) { reject(err); }
+ });
+}
+
+function fileUri(filePath: string): string {
+ if (/^(ms-|http|file:)/i.test(filePath)) return filePath;
+ return 'file:///' + filePath.replace(/\\/g, '/');
+}
+
+function bytesToStream(bytes: Uint8Array): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(bytes as never);
+ const buffer = writer.DetachBuffer();
+ const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+ NSWinRT.toPromise((stream as any).WriteAsync(buffer)).then(
+ () => { try { (stream as any).Seek(0); resolve(stream); } catch (e) { reject(e); } },
+ reject
+ );
+ } catch (e) { reject(e); }
+ });
+}
+
+function bitmapFromStream(stream: any): Promise {
+ return new Promise((resolve, reject) => {
+ // BitmapImage has UI thread affinity — create and load on the UI thread.
+ const create = () => {
+ try {
+ (stream as any).Seek(0);
+ const bmp = makeBitmapImage();
+ NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+ () => resolve(bmp),
+ reject
+ );
+ } catch (e) { reject(e); }
+ };
+ if (isMainThread()) {
+ create();
+ } else {
+ dispatchToMainThread(create);
+ }
+ });
+}
+
+function bitmapFromBytesAsync(bytes: Uint8Array): Promise {
+ return bytesToStream(bytes).then((stream) => {
+ return bitmapFromStream(stream);
+ });
+}
+
+function fetchBytesAsync(url: string): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ const httpClient = new Windows.Web.Http.HttpClient();
+ const uri = new Windows.Foundation.Uri(url);
+ NSWinRT.toPromise(httpClient.GetBufferAsync(uri)).then(
+ (buffer: any) => {
+ try {
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ const bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes as never);
+ resolve(bytes);
+ } catch (e) { reject(e); }
+ },
+ (err: any) => { reject(err); }
+ );
+ } catch (e) { reject(e); }
+ });
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+ let binary = '';
+ const len = bytes.byteLength;
+ for (let i = 0; i < len; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+ return btoa(binary);
+}
+
+function readFileBytes(filePath: string): Promise {
+ return new Promise((resolve, reject) => {
+ try {
+ NSWinRT.toPromise((Windows.Storage.PathIO as any).ReadBufferAsync(filePath)).then(
+ (buffer: any) => {
+ try {
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ const bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes as never);
+ resolve(bytes);
+ } catch (e) { reject(e); }
+ },
+ reject
+ );
+ } catch (e) { reject(e); }
+ });
+}
+
+function writeBytesToFile(filePath: string, bytes: Uint8Array): Promise {
+ return new Promise((resolve, reject) => {
+ NSWinRT.toPromise(
+ NativeScript.Widgets.ImageHelper.SaveToFileAsync(bytes as never, filePath)
+ ).then(
+ (result) => resolve(result),
+ (err) => reject(err)
+ );
+ });
+}
+
+function resizeBitmapAsync(bytes: Uint8Array, maxSize: number): Promise<{ bmp: any; bytes: Uint8Array; width: number; height: number }> {
+ return new Promise((resolve, reject) => {
+ NSWinRT.toPromise(
+ NativeScript.Widgets.ImageHelper.ResizeAsync(bytes as never, maxSize)
+ ).then(
+ (result: NativeScript.Widgets.ImageResult) => {
+ resolve({
+ bmp: result.Bitmap,
+ bytes: bytes,
+ width: result.Width,
+ height: result.Height,
+ });
+ })
+ .catch((err) => reject(err));
+
+ });
+}
+
+export class ImageSource implements ImageSourceDefinition {
+ public android: any;
+ public ios: any;
+ public windows: any; // BitmapImage or raw Uint8Array (lazy)
+
+ private _rawBytes: Uint8Array | null = null;
+ private _width: number = 0;
+ private _height: number = 0;
+ private _rotationAngle: number = 0;
+
+ public get height(): number { return this._height; }
+ public get width(): number { return this._width; }
+ public get rotationAngle(): number { return this._rotationAngle; }
+ public set rotationAngle(value: number) { this._rotationAngle = value; }
+
+ constructor(nativeSource?: any) {
+ if (nativeSource) {
+ this.setNativeSource(nativeSource);
+ }
+ }
+
+ static fromAsset(asset: ImageAsset): Promise {
+ return new Promise((resolve, reject) => {
+ asset.getImageAsync((fileOrNative: any, err: any) => {
+ if (err) { reject(err); return; }
+ if (!fileOrNative) { reject(new Error('No image from asset')); return; }
+ try {
+ if (typeof fileOrNative === 'string') {
+ ImageSource.fromFile(fileOrNative).then(resolve, reject);
+ return;
+ }
+ NSWinRT.toPromise(fileOrNative.OpenAsync(0 /* FileAccessMode.Read */)).then(
+ (stream: any) => bitmapFromStream(stream).then(
+ (bmp) => resolve(new ImageSource(bmp)),
+ reject
+ ),
+ reject
+ );
+ } catch (e) { reject(e); }
+ });
+ });
+ }
+
+ static fromUrl(url: string): Promise {
+ return httpRequest({ url, method: 'GET' }).then((response) => response.content.toNativeImage().then((value) => new ImageSource(value)));
+ }
+
+ static fromResourceSync(name: string): ImageSource {
+ if (!name) return null as any;
+ try {
+ const resourceName = name.startsWith(RES_PREFIX) ? name.slice(RES_PREFIX.length) : name;
+ const normalized = resourceName.replace(LEADING_SLASHES_RE, '').replace(BACKSLASH_RE, '/');
+ const exts = ['', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp'];
+ const resolve = (globalThis as any).__nsMsAppxResolve;
+ if (typeof resolve === 'function') {
+ for (const ext of exts) {
+ const uri = `ms-appx:///Assets/${normalized}${ext}`;
+ if (resolve(uri) != null) {
+ return ImageSource.fromFileSync(uri);
+ }
+ }
+ return null as any;
+ }
+ // Fallback when runtime hasn't registered the resolver yet
+ return ImageSource.fromFileSync(`ms-appx:///Assets/${normalized}`);
+ } catch {
+ return null as any;
+ }
+ }
+
+ static async fromResource(name: string): Promise {
+ if (!name) return null as any;
+ try {
+ const resourceName = name.startsWith(RES_PREFIX) ? name.slice(RES_PREFIX.length) : name;
+ const normalized = resourceName.replace(LEADING_SLASHES_RE, '').replace(BACKSLASH_RE, '/');
+ const exts = ['', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp'];
+
+ for (const ext of exts) {
+ try {
+ const bmp = await bitmapFromUriAsync(`ms-appx:///Assets/${normalized}${ext}`);
+ if (bmp) {
+ const src = new ImageSource(bmp);
+ src._width = bmp.PixelWidth ?? 0;
+ src._height = bmp.PixelHeight ?? 0;
+ return src;
+ }
+ } catch { /* try next extension */ }
+ }
+
+ return null as any;
+ } catch {
+ return null as any;
+ }
+ }
+
+ static fromFileSync(filePath: string): ImageSource {
+ try {
+ const bmp = makeBitmapImage();
+ const src = new ImageSource();
+ bmp.ImageOpened = () => {
+ src._width = bmp.PixelWidth ?? 0;
+ src._height = bmp.PixelHeight ?? 0;
+ //@ts-ignore
+ bmp.ImageOpened = null;
+ };
+ bmp.ImageFailed = () => {
+ //@ts-ignore
+ bmp.ImageOpened = null;
+ //@ts-ignore
+ bmp.ImageFailed = null;
+ }
+ bmp.UriSource = new Windows.Foundation.Uri(fileUri(filePath));
+ src.windows = bmp;
+ return src;
+ } catch {
+ return null as any;
+ }
+ }
+
+ static fromFile(filePath: string): Promise {
+ return readFileBytes(filePath).then((bytes) => {
+ return bitmapFromBytesAsync(bytes).then((bmp) => {
+ const src = new ImageSource(bmp);
+ src._rawBytes = bytes;
+ src._width = bmp.PixelWidth ?? 0;
+ src._height = bmp.PixelHeight ?? 0;
+ return src;
+ });
+ }).catch(() => {
+ return bitmapFromUriAsync(filePath).then((bmp) => {
+ const src = new ImageSource(bmp);
+ src._width = bmp.PixelWidth ?? 0;
+ src._height = bmp.PixelHeight ?? 0;
+ return src;
+ });
+ });
+ }
+
+ static fromDataSync(data: ArrayBuffer | Uint8Array): ImageSource {
+ const src = new ImageSource();
+ const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as ArrayBuffer);
+ src.windows = bytes;
+ src._rawBytes = bytes;
+ return src;
+ }
+
+ static fromData(data: ArrayBuffer | Uint8Array): Promise {
+ const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as ArrayBuffer);
+ return bitmapFromBytesAsync(bytes).then((bmp) => {
+ const src = new ImageSource(bmp);
+ src._rawBytes = bytes;
+ src._width = bmp.PixelWidth ?? 0;
+ src._height = bmp.PixelHeight ?? 0;
+ return src;
+ });
+ }
+
+ static fromBase64Sync(source: string): ImageSource {
+ try {
+ const bytes = Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+ return ImageSource.fromDataSync(bytes);
+ } catch {
+ return null as any;
+ }
+ }
+
+ static fromBase64(source: string): Promise {
+ try {
+ const bytes = Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+ return ImageSource.fromData(bytes);
+ } catch (e) {
+ return Promise.reject(e);
+ }
+ }
+
+ static fromSystemImageSync(name: string): ImageSource {
+ return ImageSource.fromResourceSync(name);
+ }
+
+ static fromSystemImage(name: string): Promise {
+ return ImageSource.fromResource(name);
+ }
+
+ static fromFontIconCodeSync(_source: string, _font: any, _color: any): ImageSource {
+ return null as any;
+ }
+
+ public getNativeSource(): any {
+ return this.windows ?? this._rawBytes;
+ }
+
+ public setNativeSource(source: any): void {
+ this.windows = source;
+ try {
+ if (source && typeof source.PixelWidth === 'number') {
+ this._width = source.PixelWidth;
+ this._height = source.PixelHeight;
+ }
+ } catch { }
+ }
+
+ public saveToFile(_path: string, _format: string, _quality?: number): boolean {
+ return false;
+ }
+
+ public saveToFileAsync(path: string, _format: string, _quality?: number): Promise {
+ if (!this._rawBytes) {
+ return Promise.resolve(false);
+ }
+ return writeBytesToFile(path, this._rawBytes).catch(() => false);
+ }
+
+ public toBase64String(_format: string, _quality?: number): string {
+ if (!this._rawBytes) return '';
+ try {
+ return bytesToBase64(this._rawBytes);
+ } catch {
+ return '';
+ }
+ }
+
+ public toBase64StringAsync(format: string, quality?: number): Promise {
+ return Promise.resolve(this.toBase64String(format, quality));
+ }
+
+ public resize(_maxSize: number, _options?: any): ImageSource {
+ return this;
+ }
+
+ public resizeAsync(maxSize: number, _options?: any): Promise {
+ if (!this._rawBytes) {
+ return Promise.resolve(this);
+ }
+ return resizeBitmapAsync(this._rawBytes, maxSize).then(({ bmp, bytes, width, height }) => {
+ const src = new ImageSource(bmp);
+ src._rawBytes = bytes;
+ src._width = width;
+ src._height = height;
+ return src;
+ }).catch(() => this);
+ }
+}
diff --git a/packages/core/package.json b/packages/core/package.json
index 937baae32a..673afd699f 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -73,7 +73,8 @@
"nativescript": {
"platforms": {
"ios": "6.0.0",
- "android": "6.0.0"
+ "android": "6.0.0",
+ "windows": "9.1.0"
},
"hooks": [
{
diff --git a/packages/core/platform/device/index.windows.ts b/packages/core/platform/device/index.windows.ts
new file mode 100644
index 0000000000..1b42bd9fea
--- /dev/null
+++ b/packages/core/platform/device/index.windows.ts
@@ -0,0 +1,103 @@
+import { Screen } from '../screen';
+
+const MIN_TABLET_PIXELS = 600;
+
+class DeviceRef {
+ private _manufacturer: string;
+ private _model: string;
+ private _osVersion: string;
+ private _uuid: string;
+
+ get manufacturer(): string {
+ if (!this._manufacturer) {
+ try {
+ this._manufacturer = Windows.System.Profile.SystemManufacturerInfo.SmbiosInfo.SystemManufacturer || 'Microsoft';
+ } catch {
+ this._manufacturer = 'Microsoft';
+ }
+ }
+ return this._manufacturer;
+ }
+
+ get os(): string {
+ return 'Windows';
+ }
+
+ get osVersion(): string {
+ if (!this._osVersion) {
+ try {
+ const versionStr = Windows.System.Profile.AnalyticsInfo.VersionInfo.DeviceFamilyVersion;
+ const version = parseInt(versionStr, 10);
+ if (!isNaN(version)) {
+ const major = (version / 0x1000000000000) & 0xffff;
+ const minor = (version / 0x100000000) & 0xffff;
+ const build = (version / 0x10000) & 0xffff;
+ this._osVersion = `${major}.${minor}.${build}`;
+ } else {
+ this._osVersion = versionStr || 'unknown';
+ }
+ } catch {
+ this._osVersion = 'unknown';
+ }
+ }
+ return this._osVersion;
+ }
+
+ get model(): string {
+ if (!this._model) {
+ try {
+ this._model = Windows.System.Profile.SystemManufacturerInfo.SmbiosInfo.SystemProductName || 'Windows PC';
+ } catch {
+ this._model = 'Windows PC';
+ }
+ }
+ return this._model;
+ }
+
+ get sdkVersion(): string {
+ return this.osVersion;
+ }
+
+ get deviceType(): 'Phone' | 'Tablet' {
+ const dips = Math.min(Screen.mainScreen.widthPixels, Screen.mainScreen.heightPixels) / Screen.mainScreen.scale;
+ return dips >= MIN_TABLET_PIXELS ? 'Tablet' : 'Phone';
+ }
+
+ get uuid(): string {
+ if (!this._uuid) {
+ try {
+ const systemId = Windows.System.Profile.SystemIdentification.GetSystemIdForPublisher();
+ const buffer = systemId.Id;
+ const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+ const bytes = new Uint8Array(buffer.Length);
+ reader.ReadBytes(bytes);
+ this._uuid = Array.from(bytes)
+ .map((b) => b.toString(16).padStart(2, '0'))
+ .join('');
+ } catch {
+ this._uuid = 'windows-' + Math.random().toString(36).substr(2, 9);
+ }
+ }
+ return this._uuid;
+ }
+
+ get language(): string {
+ try {
+ return Windows.Globalization.Language.CurrentInputMethodLanguageTag || 'en';
+ } catch {
+ return 'en';
+ }
+ }
+
+ get region(): string {
+ try {
+ return Windows.System.UserProfile.GlobalizationPreferences.HomeGeographicRegion || 'US';
+ } catch {
+ return 'US';
+ }
+ }
+}
+
+export const Device = new DeviceRef();
+
+export const device = Device;
diff --git a/packages/core/platform/screen/index.windows.ts b/packages/core/platform/screen/index.windows.ts
new file mode 100644
index 0000000000..f637d27794
--- /dev/null
+++ b/packages/core/platform/screen/index.windows.ts
@@ -0,0 +1,41 @@
+class MainScreen {
+ get widthPixels(): number {
+ try {
+ return Windows.Graphics.Display.DisplayInformation.GetForCurrentView().ScreenWidthInRawPixels;
+ } catch {
+ return 1920;
+ }
+ }
+
+ get heightPixels(): number {
+ try {
+ return Windows.Graphics.Display.DisplayInformation.GetForCurrentView().ScreenHeightInRawPixels;
+ } catch {
+ return 1080;
+ }
+ }
+
+ get scale(): number {
+ try {
+ return Windows.Graphics.Display.DisplayInformation.GetForCurrentView().RawPixelsPerViewPixel || 1;
+ } catch {
+ return 1;
+ }
+ }
+
+ get widthDIPs(): number {
+ return this.widthPixels / this.scale;
+ }
+
+ get heightDIPs(): number {
+ return this.heightPixels / this.scale;
+ }
+
+ public _updateMetrics(): void {}
+}
+
+export class Screen {
+ static mainScreen = new MainScreen();
+}
+
+export const screen = Screen;
diff --git a/packages/core/platforms/windows/NativeScript.Widgets.dll b/packages/core/platforms/windows/NativeScript.Widgets.dll
new file mode 100644
index 0000000000..a43b2f1773
Binary files /dev/null and b/packages/core/platforms/windows/NativeScript.Widgets.dll differ
diff --git a/packages/core/references.d.ts b/packages/core/references.d.ts
index 4300b64aee..9306e7dddf 100644
--- a/packages/core/references.d.ts
+++ b/packages/core/references.d.ts
@@ -8,3 +8,6 @@
///
///
///
+///
+///
+///
diff --git a/packages/core/text/index.windows.ts b/packages/core/text/index.windows.ts
new file mode 100644
index 0000000000..e1377eb270
--- /dev/null
+++ b/packages/core/text/index.windows.ts
@@ -0,0 +1,13 @@
+export * from './text-common';
+
+export namespace encoding {
+ export const UTF_16LE = 1200; // UTF-16LE
+ export const UTF_16BE = 1201; // UTF-16BE
+ export const UTF_8 = 65001; // CP_UTF8
+
+ export const US_ASCII = 20127; // US-ASCII
+ export const ISO_8859_1 = 28591; // ISO-8859-1
+
+ // UTF-16 on Windows is effectively UTF-16LE.
+ export const UTF_16 = UTF_16LE;
+}
\ No newline at end of file
diff --git a/packages/core/timer/index.windows.ts b/packages/core/timer/index.windows.ts
new file mode 100644
index 0000000000..f54a9c3c19
--- /dev/null
+++ b/packages/core/timer/index.windows.ts
@@ -0,0 +1,25 @@
+// __ns__setTimeout / __ns__setInterval are Rust-backed timers registered by
+// the windows-runtime. They use a background scheduler thread and post
+// callbacks back to the V8 thread via a per-thread channel that is drained
+// on every pump() tick — no XAML dispatcher required.
+declare function __ns__setTimeout(callback: Function, ms: number): number;
+declare function __ns__setInterval(callback: Function, ms: number): number;
+declare function __ns__clearTimeout(id: number): void;
+declare function __ns__clearInterval(id: number): void;
+
+export function setTimeout(callback: Function, milliseconds = 0, ...args: any[]): number {
+ milliseconds += 0;
+ const invoke = args.length ? () => callback(...args) : callback;
+ return __ns__setTimeout(zonedCallback(invoke), milliseconds);
+}
+
+export function clearTimeout(id: number): void {
+ __ns__clearTimeout(id);
+}
+
+export function setInterval(callback: Function, milliseconds = 0, ...args: []): number {
+ const invoke = args.length ? () => callback(...args) : callback;
+ return __ns__setInterval(zonedCallback(invoke), milliseconds);
+}
+
+export const clearInterval = clearTimeout;
diff --git a/packages/core/ui/action-bar/index.windows.ts b/packages/core/ui/action-bar/index.windows.ts
new file mode 100644
index 0000000000..f342fa45e0
--- /dev/null
+++ b/packages/core/ui/action-bar/index.windows.ts
@@ -0,0 +1,25 @@
+export * from './action-bar-common';
+
+import { ActionBarBase, ActionItemBase } from './action-bar-common';
+
+export class ActionItem extends ActionItemBase {}
+
+export class NavigationButton extends ActionItem {}
+
+export class ActionBar extends ActionBarBase {
+ get windows(): undefined {
+ return undefined;
+ }
+
+ public update(): void {
+ const page = this.parent as any;
+ if (!page) return;
+ const frame = page.frame as any;
+ if (!frame?._updateActionBar) return;
+ frame._updateActionBar(page);
+ }
+
+ public _onTitlePropertyChanged(): void {
+ this.update();
+ }
+}
diff --git a/packages/core/ui/activity-indicator/index.windows.ts b/packages/core/ui/activity-indicator/index.windows.ts
new file mode 100644
index 0000000000..4a7b6a604f
--- /dev/null
+++ b/packages/core/ui/activity-indicator/index.windows.ts
@@ -0,0 +1,68 @@
+import { colorProperty, visibilityProperty } from '../styling/style-properties';
+import { CoreTypes } from '../../core-types';
+import { ActivityIndicatorBase, busyProperty } from './activity-indicator-common';
+import { Color } from '../../color';
+export * from './activity-indicator-common';
+
+export class ActivityIndicator extends ActivityIndicatorBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.ProgressBar;
+
+ public createNativeView(): Object {
+ const indicator = new Windows.UI.Xaml.Controls.ProgressBar();
+ indicator.IsIndeterminate = true;
+ indicator.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
+ return indicator;
+ }
+
+
+ [busyProperty.getDefault](): boolean {
+ return false;
+ }
+ [busyProperty.setNative](value: boolean) {
+ if (this.visibility === CoreTypes.Visibility.visible) {
+ this.nativeViewProtected.Visibility = value ? Windows.UI.Xaml.Visibility.Visible : Windows.UI.Xaml.Visibility.Collapsed;
+ }
+ }
+
+
+ [visibilityProperty.getDefault](): CoreTypes.VisibilityType {
+ return CoreTypes.Visibility.hidden;
+ }
+
+ [visibilityProperty.setNative](value: CoreTypes.VisibilityType) {
+ switch (value) {
+ case CoreTypes.Visibility.visible:
+ this.nativeViewProtected.Visibility = this.busy ? Windows.UI.Xaml.Visibility.Visible : Windows.UI.Xaml.Visibility.Collapsed;
+ break;
+ case CoreTypes.Visibility.hidden:
+ this.nativeViewProtected.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
+ break;
+ case CoreTypes.Visibility.collapse:
+ this.nativeViewProtected.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
+ break;
+ default:
+ throw new Error(`Invalid visibility value: ${value}. Valid values are: "${CoreTypes.Visibility.visible}", "${CoreTypes.Visibility.hidden}", "${CoreTypes.Visibility.collapse}".`);
+ }
+ }
+
+
+ [colorProperty.getDefault](): number {
+ return -1;
+ }
+ [colorProperty.setNative](value: number | Color) {
+ const color = value instanceof Color ? value.windows : value
+ if (color) {
+ if (typeof color === 'number') {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(
+ new Color(color).windows
+ );
+ } else {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(
+ color
+ );
+ }
+ } else {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush();
+ }
+ }
+}
diff --git a/packages/core/ui/animation/index.windows.ts b/packages/core/ui/animation/index.windows.ts
new file mode 100644
index 0000000000..16c59b5f51
--- /dev/null
+++ b/packages/core/ui/animation/index.windows.ts
@@ -0,0 +1,388 @@
+export * from './animation-common';
+export * from './animation-shared';
+export * from './animation-types';
+
+export function _resolveAnimationCurve(curve: any): any {
+ return curve;
+}
+
+import { AnimationBase, Properties } from './animation-common';
+import type { View } from '../core/view';
+import { _ensureNativeTransforms } from '../core/view';
+
+function _applyFinalValue(target: any, property: string, to: any): void {
+ try {
+ switch (property) {
+ case Properties.opacity: target.opacity = to; break;
+ case Properties.translate: target.translateX = to?.x ?? 0; target.translateY = to?.y ?? 0; break;
+ case Properties.scale: target.scaleX = to?.x ?? 1; target.scaleY = to?.y ?? 1; break;
+ case Properties.rotate: target.rotate = to?.z ?? to; break;
+ case Properties.width: target.width = typeof to === 'object' ? (to?.value ?? to) : to; break;
+ case Properties.height: target.height = typeof to === 'object' ? (to?.value ?? to) : to; break;
+ default: break;
+ }
+ } catch (_e) {}
+}
+
+// Per-native-view, per-property storyboard conflict tracking.
+// When a new animation starts on the same native element + property, the previous
+// storyboard is stopped immediately and its promise resolved so the chain continues.
+const _activeStoryboards = new WeakMap void>>();
+
+function _cancelActiveStoryboard(native: object, property: string): void {
+ const map = _activeStoryboards.get(native);
+ if (!map) return;
+ const cancel = map.get(property);
+ if (cancel) { cancel(); map.delete(property); }
+}
+
+function _registerActiveStoryboard(native: object, property: string, cancel: () => void): void {
+ let map = _activeStoryboards.get(native);
+ if (!map) { map = new Map(); _activeStoryboards.set(native, map); }
+ map.set(property, cancel);
+}
+
+function _clearActiveStoryboard(native: object, property: string): void {
+ _activeStoryboards.get(native)?.delete(property);
+}
+
+export class Animation extends AnimationBase {
+ constructor(animationDefinitions: any[], playSequentially?: boolean) {
+ super(animationDefinitions, playSequentially);
+ }
+
+
+ // Track running XAML storyboards so we can stop them on cancel
+ private _runningStoryboards: Array<{ storyboard: any; native: any; props: string[] }> = [];
+
+
+ private _startStoryboardForProperty(native: any, property: string, to: any, dur: number, del: number, tid2: string, target?: any) {
+ return new Promise((resolve) => {
+ try {
+ const sb = new Windows.UI.Xaml.Media.Animation.Storyboard();
+ // DurationHelper.FromTimeSpan expects a raw TimeSpan struct by value.
+ // BeginTime expects IReference — box it via PropertyValue.
+ const makeTimeSpanStruct = (ms: number) => ({ Duration: Math.round(ms * 10000) });
+ const makeTimeSpanRef = (ms: number) =>
+ Windows.Foundation.PropertyValue.CreateTimeSpan(makeTimeSpanStruct(ms)) as any;
+
+ const duration = Windows.UI.Xaml.DurationHelper.FromTimeSpan(makeTimeSpanStruct(dur));
+ const beginTime = del > 0 ? makeTimeSpanRef(del) : null;
+
+ switch (property) {
+ case Properties.scale: {
+ const transforms = _ensureNativeTransforms(native);
+ const st = transforms?.scale;
+ if (!st) break;
+ const sx = (to && (to.x ?? to)) || 1;
+ const sy = (to && (to.y ?? to)) || 1;
+ const daX = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ daX.To = sx;
+ daX.Duration = duration;
+ if (beginTime) daX.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(daX, st);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(daX, 'ScaleX');
+ sb.Children.Append(daX);
+
+ const daY = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ daY.To = sy;
+ daY.Duration = duration;
+ if (beginTime) daY.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(daY, st);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(daY, 'ScaleY');
+ sb.Children.Append(daY);
+ break;
+ }
+ case Properties.rotate: {
+ const transforms = _ensureNativeTransforms(native);
+ const rt = transforms?.rotate;
+ if (!rt) break;
+ const angle = (to && (to.z ?? to)) || 0;
+ const da = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ da.To = angle;
+ da.Duration = duration;
+ if (beginTime) da.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(da, rt);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(da, 'Angle');
+ sb.Children.Append(da);
+ break;
+ }
+ case Properties.translate: {
+ const transforms = _ensureNativeTransforms(native);
+ const tt = transforms?.translate;
+ if (!tt) break;
+ // Values are already in DIPs (same as iOS) — no density conversion needed.
+ const vx = (to && (to.x ?? to)) || 0;
+ const vy = (to && (to.y ?? 0)) || 0;
+ const dax = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ dax.To = vx;
+ dax.Duration = duration;
+ if (beginTime) dax.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(dax, tt);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(dax, 'X');
+ sb.Children.Append(dax);
+ const day = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ day.To = vy;
+ day.Duration = duration;
+ if (beginTime) day.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(day, tt);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(day, 'Y');
+ sb.Children.Append(day);
+ break;
+ }
+ case Properties.width:
+ case Properties.height: {
+ // PercentLength { value, unit } or plain number — both in DIPs.
+ const toVal = typeof to === 'object' ? (to?.value ?? 0) : (to ?? 0);
+ const prop = property === Properties.width ? 'Width' : 'Height';
+ const fromVal = property === Properties.width
+ ? ((native as any).ActualWidth || (native as any).Width)
+ : ((native as any).ActualHeight || (native as any).Height);
+ const da = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ da.To = toVal;
+ // Layout-affecting animations are disabled by default in WinUI — must opt in.
+ da.EnableDependentAnimation = true;
+ if (isFinite(fromVal) && fromVal > 0) da.From = fromVal;
+ da.Duration = duration;
+ if (beginTime) da.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(da, native);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(da, prop);
+ sb.Children.Append(da);
+ break;
+ }
+ case Properties.opacity: {
+ const da = new Windows.UI.Xaml.Media.Animation.DoubleAnimation();
+ da.To = to;
+ da.Duration = duration;
+ if (beginTime) da.BeginTime = beginTime;
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTarget(da, native);
+ Windows.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(da, 'Opacity');
+ sb.Children.Append(da);
+ break;
+ }
+ case Properties.backgroundColor: {
+ // ColorAnimation.To expects IReference which cannot
+ // be boxed without a WinRT helper. Use a JS lerp loop instead:
+ // read current brush color, interpolate, and write directly to brush.Color
+ // (a struct property setter that works correctly after the struct ABI fix).
+ try {
+ const toColor = to && typeof to === 'object' && to.r !== undefined ? to : null;
+ if (!toColor) { resolve(); return; }
+
+ const toA = Math.round(toColor.a ?? 255);
+ const toR = Math.round(toColor.r ?? 0);
+ const toG = Math.round(toColor.g ?? 0);
+ const toB = Math.round(toColor.b ?? 0);
+
+ let fromA = 255, fromR = 0, fromG = 0, fromB = 0;
+ try {
+ const existing = native.Background;
+ if (existing instanceof Windows.UI.Xaml.Media.SolidColorBrush) {
+ const c = (existing as Windows.UI.Xaml.Media.SolidColorBrush).Color;
+ fromA = (c as any).A ?? 255;
+ fromR = (c as any).R ?? 0;
+ fromG = (c as any).G ?? 0;
+ fromB = (c as any).B ?? 0;
+ }
+ } catch (_e) {}
+
+ const brush = new Windows.UI.Xaml.Media.SolidColorBrush(
+ Windows.UI.ColorHelper.FromArgb(fromA, fromR, fromG, fromB)
+ );
+ native.Background = brush;
+ try { (native as any).Resources.Insert('ButtonBackground', brush); } catch (_re) {}
+ try { (native as any).Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_re) {}
+ try { (native as any).Resources.Insert('ButtonBackgroundPressed', brush); } catch (_re) {}
+
+ let colorSettled = false;
+ let colorTimer: any;
+ const colorDone = () => {
+ if (colorSettled) return;
+ colorSettled = true;
+ clearTimeout(colorTimer);
+ try { brush.Color = Windows.UI.ColorHelper.FromArgb(toA, toR, toG, toB); } catch (_e) {}
+ resolve();
+ };
+ const animStart = Date.now() + del;
+ const step = () => {
+ if (colorSettled) return;
+ const now = Date.now();
+ if (now < animStart) { colorTimer = setTimeout(step, animStart - now); return; }
+ const t = Math.min(1, (now - animStart) / Math.max(1, dur));
+ const a = Math.round(fromA + (toA - fromA) * t);
+ const r = Math.round(fromR + (toR - fromR) * t);
+ const g = Math.round(fromG + (toG - fromG) * t);
+ const b = Math.round(fromB + (toB - fromB) * t);
+ try { brush.Color = Windows.UI.ColorHelper.FromArgb(a, r, g, b); } catch (_e) {}
+ if (t < 1) { colorTimer = setTimeout(step, 16); } else { colorDone(); }
+ };
+ colorTimer = setTimeout(step, 0);
+ setTimeout(colorDone, dur + del + 300);
+ } catch (_e) { resolve(); }
+ return;
+ }
+ default:
+ break;
+ }
+
+ // Cancel any previous animation on the same native element + property so
+ // animations don't fight each other (e.g. down-animation vs up-animation).
+ _cancelActiveStoryboard(native, property);
+
+ try {
+ let settled = false;
+ const done = (applyFinal = true) => {
+ if (settled) return;
+ settled = true;
+ clearTimeout(safetyTimer);
+ _clearActiveStoryboard(native, property);
+ if (applyFinal && target) {
+ try { _applyFinalValue(target, property, to); } catch (_e) {}
+ }
+ try { sb.Stop(); } catch (_e) {}
+ for (let i = 0; i < this._runningStoryboards.length; i++) {
+ if (this._runningStoryboards[i].storyboard === sb) {
+ this._runningStoryboards.splice(i, 1);
+ break;
+ }
+ }
+ resolve();
+ };
+ // Safety timeout: resolve even if Completed never fires
+ const safetyTimer = setTimeout(done, Math.max(0, dur + del + 300));
+ // Use Windows.Foundation.EventHandler delegate — the correct type for
+ // Timeline.Completed in the WinRT projection. Falls back to addEventListener.
+ try {
+ sb.Completed = new Windows.Foundation.EventHandler((_s: any, _e: any) => done()) as any;
+ } catch (_e) {
+ try { (sb as any).addEventListener?.('completed', () => done()); } catch (_e2) { /* safety timer covers */ }
+ }
+ _registerActiveStoryboard(native, property, () => done(false));
+ this._runningStoryboards.push({ storyboard: sb, native, props: [property] });
+ sb.Begin();
+ } catch (err) {
+ console.error('[Animation.Windows] Storyboard begin failed', err);
+ resolve();
+ }
+ } catch (err) {
+ console.error('[Animation.Windows] Storyboard fallback building failed', err);
+ resolve();
+ }
+ });
+ }
+
+ play(_resetDelay?: boolean): any {
+ const playPromise = super.play();
+
+
+ const run = async () => {
+ try {
+ if (this._playSequentially) {
+ for (const anim of this._propertyAnimations) {
+ await this._playKeyframeAnimation(anim);
+ }
+
+ } else {
+ await Promise.all(this._propertyAnimations.map((anim) => this._playKeyframeAnimation(anim)));
+ }
+
+ this._resolveAnimationFinishedPromise();
+ } catch (err) {
+ this._rejectAnimationFinishedPromise();
+ }
+ };
+
+ run();
+ return playPromise;
+ }
+
+ public cancel(): void {
+ // Stop any running XAML storyboards
+ try {
+ for (const it of this._runningStoryboards) {
+ try { it.storyboard.Stop(); } catch (_e) { }
+ }
+ } catch (_e) { }
+ this._runningStoryboards.length = 0;
+
+ super.cancel();
+ // Guard: only reject if play() has been called (sets _reject via super.play())
+ if (this.isPlaying) {
+ this._rejectAnimationFinishedPromise();
+ }
+ }
+
+ _resolveAnimationCurve(curve: any): any {
+ return curve;
+ }
+
+ _playKeyframeAnimation(animation: any, _delay?: number): any {
+ return new Promise((resolve, _reject) => {
+ if (!animation || !animation.target) {
+ resolve();
+ return;
+ }
+
+ const target = animation.target as View;
+ const property = animation.property;
+ const to = animation.value;
+ const duration = typeof animation.duration === 'number' ? animation.duration : 300;
+ const delay = typeof animation.delay === 'number' ? animation.delay : 0;
+ const iterations = typeof animation.iterations === 'number' && animation.iterations > 0 ? animation.iterations : 1;
+ const curve = typeof animation.curve === 'function' ? animation.curve : (t: number) => t;
+
+ let startValues: any = null;
+
+ function getNumeric(v: any, fallback = 0) {
+ return typeof v === 'number' ? v : fallback;
+ }
+
+ // Determine start values
+ switch (property) {
+ case Properties.opacity:
+ startValues = { opacity: getNumeric((target as any).opacity ?? (target as any).get?.('opacity') ?? 1, 1) };
+ break;
+ case Properties.translate:
+ startValues = {
+ x: getNumeric((target as any).translateX ?? 0, 0),
+ y: getNumeric((target as any).translateY ?? 0, 0),
+ };
+ break;
+ case Properties.scale:
+ startValues = {
+ x: getNumeric((target as any).scaleX ?? (target as any).scale ?? 1, 1),
+ y: getNumeric((target as any).scaleY ?? (target as any).scale ?? 1, 1),
+ };
+ break;
+ case Properties.rotate:
+ startValues = { rotate: getNumeric((target as any).rotate ?? 0, 0) };
+ break;
+ case Properties.backgroundColor:
+ const bg = (target as any).backgroundColor ?? (target as any).style?.backgroundColor ?? null;
+ startValues = { color: bg };
+ break;
+ default:
+ startValues = {};
+ break;
+ }
+
+ const native = (target as any).nativeViewProtected;
+ if (native) {
+ // Use XAML Storyboard for all properties — reliable, no Composition fallback needed
+ this._startStoryboardForProperty(native, property, to, duration, delay, '', target).then(() => resolve());
+ } else {
+ // No native view yet — apply final value immediately so the animation doesn't hang
+ _applyFinalValue(target, property, to);
+ resolve();
+ }
+ });
+ }
+
+ _createiOSAnimationFunction(_animation: Properties, _delay?: number): any {
+ return null;
+ }
+
+ static _getTransformAnimationInfo(_view: View, _transformation: any): any {
+ return {};
+ }
+}
diff --git a/packages/core/ui/button/index.windows.ts b/packages/core/ui/button/index.windows.ts
new file mode 100644
index 0000000000..e9f03f1fac
--- /dev/null
+++ b/packages/core/ui/button/index.windows.ts
@@ -0,0 +1,114 @@
+export * from './button-common';
+
+import { ButtonBase } from './button-common';
+import { PseudoClassHandler } from '../core/view';
+import { TouchGestureEventData, TouchAction, GestureTypes } from '../gestures';
+
+function onButtonStateChange(args: any) {
+ const button = args.object as Button;
+
+ switch (args.action) {
+ case TouchAction.up:
+ case TouchAction.cancel:
+ button._removeVisualState('highlighted');
+ try {
+ if (typeof button._defaultOpacity === 'number' && button.nativeViewProtected) {
+ (button.nativeViewProtected as any).Opacity = button._defaultOpacity;
+ }
+ } catch (_e) {}
+ break;
+ case TouchAction.down:
+ button._addVisualState('highlighted');
+ try {
+ if (button.nativeViewProtected) {
+ if (typeof button._defaultOpacity !== 'number') {
+ button._defaultOpacity = (button.nativeViewProtected as any).Opacity || 1;
+ }
+ (button.nativeViewProtected as any).Opacity = Math.max(0, (button._defaultOpacity || 1) * 0.85);
+ }
+ } catch (_e) {}
+ break;
+ }
+}
+
+
+export class Button extends ButtonBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Button;
+ private _delegate: any = null;
+ private _delegateUsedAddListener: boolean = false;
+ private _windows: Windows.UI.Xaml.Controls.Button;
+ private _defaultOpacity?: number;
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Button();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.Button {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ const nativeView = this.nativeViewProtected;
+ const that = new WeakRef(this);
+ let usedAdd = false;
+ try {
+ this._delegate = new Windows.UI.Xaml.RoutedEventHandler((args) => {
+ const owner = that.deref();
+ if (!owner) {
+ return;
+ }
+ owner.notify({ eventName: ButtonBase.tapEvent, object: owner });
+ });
+ nativeView.Click = this._delegate as never;
+ } catch (_e) {
+ this._delegate = (args: any) => {
+ const owner = that.deref();
+ if (!owner) return;
+ owner.notify({ eventName: ButtonBase.tapEvent, object: owner });
+ };
+ try {
+ nativeView.Click = this._delegate as never;
+ } catch (_e2) {
+ try {
+ if (typeof (nativeView as any).addEventListener === 'function') {
+ (nativeView as any).addEventListener('click', this._delegate);
+ usedAdd = true;
+ }
+ } catch (_e3) {}
+ }
+ }
+ this._delegateUsedAddListener = usedAdd;
+ // remember default opacity for pressed-state visual
+ try {
+ this._defaultOpacity = (nativeView as any).Opacity || 1;
+ } catch (_e) {}
+ }
+
+ public disposeNativeView(): void {
+ if (this._delegate) {
+ try { this.nativeViewProtected.Click = null as never; } catch (_e) {}
+ if (this._delegateUsedAddListener) {
+ try { (this.nativeViewProtected as any).removeEventListener('click', this._delegate); } catch (_e) {}
+ }
+ this._delegate = null;
+ this._delegateUsedAddListener = false;
+ }
+ super.disposeNativeView();
+ }
+
+ @PseudoClassHandler('normal', 'highlighted', 'pressed', 'active')
+ _updateButtonStateChangeHandler(subscribe: boolean) {
+ console.log('Updating button state change handler for Windows is not implemented yet.'); // TODO: Implement updating button state change handler for Windows
+ if (subscribe) {
+ this.on(GestureTypes[GestureTypes.touch], onButtonStateChange);
+ } else {
+ this.off(GestureTypes[GestureTypes.touch], onButtonStateChange);
+ this._removeVisualState('highlighted');
+ }
+ }
+}
diff --git a/packages/core/ui/core/control-state-change/index.windows.ts b/packages/core/ui/core/control-state-change/index.windows.ts
new file mode 100644
index 0000000000..804f5d0b18
--- /dev/null
+++ b/packages/core/ui/core/control-state-change/index.windows.ts
@@ -0,0 +1,5 @@
+// Windows stub — ControlStateChangeListener is iOS-only.
+export class ControlStateChangeListener {
+ constructor(_view: any, _callback: (v: any, s: string) => void) {}
+ stop() {}
+}
diff --git a/packages/core/ui/core/view-base/index.ts b/packages/core/ui/core/view-base/index.ts
index e4b2cd051e..dc0ea90b62 100644
--- a/packages/core/ui/core/view-base/index.ts
+++ b/packages/core/ui/core/view-base/index.ts
@@ -336,6 +336,7 @@ export abstract class ViewBase extends Observable {
private _onUnloadedCalled = false;
private _iosView: Object;
private _androidView: Object;
+ private _windowsView: Object;
private _style: Style;
private _isLoaded: boolean;
@@ -1196,6 +1197,8 @@ export abstract class ViewBase extends Observable {
}
}
}
+ }else if(__WINDOWS__){
+ this._windowsView = nativeView;
} else {
this._iosView = nativeView;
}
diff --git a/packages/core/ui/core/view/index.windows.ts b/packages/core/ui/core/view/index.windows.ts
new file mode 100644
index 0000000000..6e9c607cb0
--- /dev/null
+++ b/packages/core/ui/core/view/index.windows.ts
@@ -0,0 +1,1135 @@
+export * from './view-common';
+export * from './view-helper';
+export * from '../properties';
+
+import { ViewCommon, originXProperty, originYProperty } from './view-common';
+import type { CoreTypes } from '../../../core-types';
+import { visibilityProperty, opacityProperty, backgroundInternalProperty, translateXProperty, translateYProperty, scaleXProperty, scaleYProperty, rotateProperty, rotateXProperty, rotateYProperty, perspectiveProperty, horizontalAlignmentProperty, verticalAlignmentProperty, paddingTopProperty, paddingRightProperty, paddingBottomProperty, paddingLeftProperty } from '../../styling/style-properties';
+import { LinearGradient } from '../../styling/linear-gradient';
+import { widthProperty, heightProperty, minWidthProperty, minHeightProperty, marginLeftProperty, marginTopProperty, marginRightProperty, marginBottomProperty } from '../../styling/style-properties';
+import { layout } from '../../../utils';
+import { unsetValue } from '../properties/property-shared';
+import { Background } from '../../styling/background';
+import { Color } from '../../../color';
+import { hiddenProperty } from '../view-base';
+type WindowsColor = Color & { windows: Windows.UI.Color, windowsArgb: number };
+
+let _defaultBackground: Windows.UI.Color;
+export function getDefaultBackground() {
+ if (!_defaultBackground) {
+ _defaultBackground = Windows.UI.ColorHelper.FromArgb(0, 0, 0, 0);
+ }
+ return _defaultBackground;
+}
+
+// NOTE: `_nativeBackgroundState` will be initialized on the prototype after the class definition
+
+function toXamlLength(value: CoreTypes.PercentLengthType | CoreTypes.LengthType): number {
+ if (!value || value === 'auto') return NaN;
+ if (typeof value === 'number') return value;
+ if (typeof value === 'object' && 'value' in value) {
+ if ((value as any).unit === '%') return NaN; // percent not directly settable
+ return (value as any).value ?? NaN;
+ }
+ return NaN;
+}
+
+function _argbToWinColor(argb: number): Windows.UI.Color {
+ return Windows.UI.ColorHelper.FromArgb((argb >>> 24) & 0xFF, (argb >> 16) & 0xFF, (argb >> 8) & 0xFF, argb & 0xFF);
+}
+
+
+function _resolveToWinColor(color: any): Windows.UI.Color | null {
+ if (!color) return null;
+
+ if (typeof color.windows !== 'undefined') {
+ try { return color.windows; } catch (_e) {}
+ }
+
+ if (typeof color.A === 'number' && typeof color.R === 'number') {
+ return color as Windows.UI.Color;
+ }
+
+ if (typeof color === 'number') {
+ return _argbToWinColor(color >>> 0);
+ }
+
+ if (typeof color === 'string') {
+ try {
+ return new Color(color).windows;
+ } catch (_e) {}
+ }
+ return null;
+}
+
+
+export function _ensureNativeTransforms(native: any): { scale: any; rotate: any; translate: any } | null {
+ try {
+ if (native.__ns_transforms) return native.__ns_transforms;
+
+ const tg = new Windows.UI.Xaml.Media.TransformGroup();
+ const scale = new Windows.UI.Xaml.Media.ScaleTransform();
+ const rotate = new Windows.UI.Xaml.Media.RotateTransform();
+ const translate = new Windows.UI.Xaml.Media.TranslateTransform();
+ tg.Children.Append(scale);
+ tg.Children.Append(rotate);
+ tg.Children.Append(translate);
+ native.RenderTransform = tg;
+
+ const result = { scale, rotate, translate };
+ native.__ns_transforms = result;
+ return result;
+ } catch (_e) {
+ return null;
+ }
+}
+
+const hidden = Symbol('[[hidden]]');
+function setVisibility(nativeView: Windows.UI.Xaml.UIElement & { [hidden]?: boolean }, value: CoreTypes.VisibilityType) {
+ switch (value) {
+ case "collapse":
+ case "collapsed":
+ nativeView[hidden] = true;
+ nativeView.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
+ break;
+ case "hidden":
+ nativeView[hidden] = true;
+ nativeView.Opacity = 0;
+ nativeView.Visibility = Windows.UI.Xaml.Visibility.Visible;
+ break;
+ case "visible":
+ nativeView[hidden] = false;
+ nativeView.Opacity = 1;
+ nativeView.Visibility = Windows.UI.Xaml.Visibility.Visible;
+ break;
+ default:
+ }
+}
+
+function getVisibility(nativeView: Windows.UI.Xaml.UIElement & { [hidden]?: boolean }): CoreTypes.VisibilityType {
+ if (nativeView[hidden]) {
+ if (nativeView.Opacity === 0) {
+ return "hidden";
+ } else {
+ if (nativeView.Visibility === Windows.UI.Xaml.Visibility.Collapsed) {
+ return "collapse";
+ }
+ }
+ }
+ return "visible";
+}
+
+class CompositionBorderHandler {
+ private _element: any;
+ private _rootVisual: any;
+ private _container: any;
+ private _top: any; private _bottom: any; private _left: any; private _right: any;
+ private _topBrush: any; private _bottomBrush: any; private _leftBrush: any; private _rightBrush: any;
+ private _clipGeometry: any = null;
+ private _shadowSprite: any = null;
+
+ constructor(element: any, rootVisual: any) {
+ this._element = element;
+ this._rootVisual = rootVisual;
+ const c = rootVisual.Compositor;
+
+ this._container = c.CreateContainerVisual();
+ const sizeAnim = c.CreateExpressionAnimation('host.Size');
+ sizeAnim.SetReferenceParameter('host', rootVisual);
+ this._container.StartAnimation('Size', sizeAnim);
+
+ this._topBrush = c.CreateColorBrush(); this._bottomBrush = c.CreateColorBrush();
+ this._leftBrush = c.CreateColorBrush(); this._rightBrush = c.CreateColorBrush();
+
+ this._top = c.CreateSpriteVisual(); this._top.Brush = this._topBrush;
+ this._bottom = c.CreateSpriteVisual(); this._bottom.Brush = this._bottomBrush;
+ this._left = c.CreateSpriteVisual(); this._left.Brush = this._leftBrush;
+ this._right = c.CreateSpriteVisual(); this._right.Brush = this._rightBrush;
+
+ this._container.Children.InsertAtTop(this._top);
+ this._container.Children.InsertAtTop(this._bottom);
+ this._container.Children.InsertAtTop(this._left);
+ this._container.Children.InsertAtTop(this._right);
+
+ Windows.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(element, this._container);
+ }
+
+ static Create(element: any): CompositionBorderHandler | null {
+ try {
+ const rootVisual = Windows.UI.Xaml.Hosting.ElementCompositionPreview.GetElementVisual(element);
+ return new CompositionBorderHandler(element, rootVisual);
+ } catch (_e) {
+ return null;
+ }
+ }
+
+ private _animate(target: any, prop: string, expr: string): void {
+ const anim = this._rootVisual.Compositor.CreateExpressionAnimation(expr);
+ anim.SetReferenceParameter('host', this._rootVisual);
+ target.StartAnimation(prop, anim);
+ }
+
+ UpdateBorderWidth(left: number, top: number, right: number, bottom: number): void {
+ this._animate(this._top, 'Offset', 'Vector3(0, 0, 0)');
+ this._animate(this._top, 'Size', `Vector2(host.Size.X, ${top})`);
+ this._animate(this._bottom, 'Offset', `Vector3(0, host.Size.Y - ${bottom}, 0)`);
+ this._animate(this._bottom, 'Size', `Vector2(host.Size.X, ${bottom})`);
+ this._animate(this._left, 'Offset', `Vector3(0, ${top}, 0)`);
+ this._animate(this._left, 'Size', `Vector2(${left}, host.Size.Y - ${top} - ${bottom})`);
+ this._animate(this._right, 'Offset', `Vector3(host.Size.X - ${right}, ${top}, 0)`);
+ this._animate(this._right, 'Size', `Vector2(${right}, host.Size.Y - ${top} - ${bottom})`);
+ }
+
+ UpdateBorderColor(left: number, top: number, right: number, bottom: number): void {
+ this._topBrush.Color = _argbToWinColor(top);
+ this._bottomBrush.Color = _argbToWinColor(bottom);
+ this._leftBrush.Color = _argbToWinColor(left);
+ this._rightBrush.Color = _argbToWinColor(right);
+ }
+
+ UpdateBorderRadius(tl: number, tr: number, br: number, bl: number): void {
+ const r = Math.max(tl, tr, br, bl);
+ if (r <= 0) {
+ this._container.Clip = null;
+ this._clipGeometry = null;
+ return;
+ }
+ const c = this._rootVisual.Compositor;
+ if (!this._clipGeometry) {
+ this._clipGeometry = c.CreateRoundedRectangleGeometry();
+ const sizeAnim = c.CreateExpressionAnimation('host.Size');
+ sizeAnim.SetReferenceParameter('host', this._rootVisual);
+ this._clipGeometry.StartAnimation('Size', sizeAnim);
+ this._container.Clip = c.CreateGeometricClip(this._clipGeometry);
+ }
+ this._clipGeometry.CornerRadius = new (Windows.Foundation.Numerics as any).Vector2(r, r);
+ }
+
+ UpdateBoxShadow(s: any | null): void {
+ if (this._shadowSprite) {
+ try { this._container.Children.Remove(this._shadowSprite); } catch (_e) {}
+ this._shadowSprite = null;
+ }
+ if (!s) return;
+ try {
+ const c = this._rootVisual.Compositor;
+ const sprite = c.CreateSpriteVisual();
+ // Leave Brush = null so DropShadow uses the visual's bounding shape as mask.
+ // A transparent brush (A=0) would make the mask fully transparent → no shadow.
+ try {
+ (sprite as any).RelativeSizeAdjustment = { X: 1, Y: 1 };
+ } catch (_e) {
+ sprite.Size = (this._rootVisual as any).Size;
+ }
+ const drop = c.CreateDropShadow();
+ if (s?.color?.windows) { drop.Color = s.color.windows; }
+ if (typeof s?.blurRadius === 'number') { drop.BlurRadius = s.blurRadius; }
+ try { drop.Offset = new Windows.Foundation.Numerics.Vector3(s?.offsetX || 0, s?.offsetY || 0, 0); } catch (_e) {}
+ sprite.Shadow = drop;
+ this._container.Children.InsertAtBottom(sprite);
+ this._shadowSprite = sprite;
+ } catch (_e) {}
+ }
+
+ Free(): void {
+ try { Windows.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(this._element, null as never); } catch (_e) { }
+ this._element = null; this._rootVisual = null; this._container = null;
+ }
+}
+
+export class View extends ViewCommon {
+ nativeViewProtected: Windows.UI.Xaml.FrameworkElement;
+
+ _nativeBackgroundState: 'invalid' | 'drawn' = 'invalid';
+
+ // Percent sizing state (null = not set)
+ private _percentWidth: number | null = null;
+ private _percentHeight: number | null = null;
+
+ // initialized below for downlevel compatibility
+
+ // XAML handles layout natively — these are no-ops on Windows
+ public onMeasure(_widthMeasureSpec: number, _heightMeasureSpec: number): void { }
+ public onLayout(_left: number, _top: number, _right: number, _bottom: number): void { }
+ public layoutNativeView(_left: number, _top: number, _right: number, _bottom: number): void { }
+
+ _redrawNativeBackground(value: any): void {
+ const native = this.nativeViewProtected as any;
+ if (!native) return;
+
+ const background = value as Background;
+
+ if (!(background && typeof background === 'object')) {
+ return;
+ }
+
+ try { console.log('[BG]', (this as any).typeName ?? (this as any).constructor?.name, 'color=', background.color?.hex, 'hasImage=', !!background.image); } catch (_) {}
+
+ // Gradient handling
+ if (background.image && typeof background.image === 'object' && 'colorStops' in background.image) {
+ try {
+ const lg: LinearGradient = background.image as any;
+ const cs = lg.colorStops || [];
+ // Create brush first so we can use its built-in GradientStops collection
+ // (GradientStopCollection is not directly constructable in WinRT JS projection)
+ const brush = new Windows.UI.Xaml.Media.LinearGradientBrush();
+ const stopsCol = brush.GradientStops;
+ for (let i = 0; i < cs.length; i++) {
+ const entry = cs[i];
+ const stop = new Windows.UI.Xaml.Media.GradientStop();
+ const resolvedColor = _resolveToWinColor(entry.color);
+ stop.Color = resolvedColor ?? Windows.UI.Colors.Transparent;
+ if (entry.offset && typeof (entry.offset as any).value === 'number') {
+ stop.Offset = (entry.offset as any).value;
+ } else {
+ stop.Offset = cs.length > 1 ? i / (cs.length - 1) : 0;
+ }
+ stopsCol.Append(stop);
+ }
+ // angle: 0 = top-to-bottom, 90deg = left-to-right (NS convention matches CSS)
+ const angleRad = typeof lg.angle === 'number' ? lg.angle : 0;
+ const dx = Math.sin(angleRad);
+ const dy = -Math.cos(angleRad);
+ brush.StartPoint = Windows.UI.Xaml.PointHelper.FromCoordinates(0.5 - dx / 2, 0.5 - dy / 2);
+ brush.EndPoint = Windows.UI.Xaml.PointHelper.FromCoordinates(0.5 + dx / 2, 0.5 + dy / 2);
+ brush.MappingMode = Windows.UI.Xaml.Media.BrushMappingMode.RelativeToBoundingBox;
+ native.Background = brush;
+ } catch (_e) { /* fallback to solid color below */ }
+ } else if (background && background.color) {
+ const winColor = _resolveToWinColor(background.color);
+ if (winColor) {
+ try {
+ const brush = new Windows.UI.Xaml.Media.SolidColorBrush(winColor);
+ native.Background = brush;
+ // For Button-like controls the default XAML template may ignore Background
+ // via its Normal-state VSM animation. Override the ButtonBackground resource
+ // so the template binding picks up our colour.
+ try { (native as any).Resources.Insert('ButtonBackground', brush); } catch (_re) {}
+ try { (native as any).Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_re) {}
+ try { (native as any).Resources.Insert('ButtonBackgroundPressed', brush); } catch (_re) {}
+ } catch (bgErr) {
+ console.error('[Windows] Background SolidColorBrush failed:', bgErr);
+ }
+ } else {
+ console.warn('[Windows] _resolveToWinColor returned null for:', background.color);
+ native.Background = null;
+ }
+ } else {
+ native.Background = null;
+ }
+
+
+ let radius = 0;
+ if (typeof background.getUniformBorderRadius === 'function') {
+ radius = background.getUniformBorderRadius();
+ }
+
+ if (!this._viewCompositionHandler) {
+ this._viewCompositionHandler = CompositionBorderHandler.Create(native);
+ }
+
+
+ if (radius > 0) {
+ const radiusDp = layout.toDeviceIndependentPixels(radius || 0);
+ if (this._viewCompositionHandler) {
+ this._viewCompositionHandler.UpdateBorderRadius(
+ radiusDp, radiusDp, radiusDp, radiusDp,
+ );
+ } else {
+ native.CornerRadius = Windows.UI.Xaml.CornerRadiusHelper.FromUniformRadius(radiusDp);
+ }
+
+ } else {
+ if (this._viewCompositionHandler) {
+ this._viewCompositionHandler.UpdateBorderRadius(
+ layout.toDeviceIndependentPixels(background.borderTopLeftRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderTopRightRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderBottomRightRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderBottomLeftRadius || 0)
+ );
+ } else {
+
+ native.CornerRadius = Windows.UI.Xaml.CornerRadiusHelper.FromRadii(
+ layout.toDeviceIndependentPixels(background.borderTopLeftRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderTopRightRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderBottomRightRadius || 0),
+ layout.toDeviceIndependentPixels(background.borderBottomLeftRadius || 0)
+ )
+ }
+ }
+
+
+ const borderWidth = typeof background.getUniformBorderWidth === 'function' ? background.getUniformBorderWidth() : 0;
+ const borderColor = (typeof background.getUniformBorderColor === 'function' ? background.getUniformBorderColor() as WindowsColor : undefined);
+ if (borderWidth && borderWidth > 0 && borderColor) {
+ const borderWidthDp = layout.toDeviceIndependentPixels(borderWidth);
+ if (this._viewCompositionHandler) {
+ this._viewCompositionHandler.UpdateBorderWidth(
+ borderWidthDp, borderWidthDp, borderWidthDp, borderWidthDp,
+ );
+
+ const uniformColor = borderColor?.windowsArgb ?? 0;
+
+ this._viewCompositionHandler.UpdateBorderColor(
+ uniformColor, uniformColor, uniformColor, uniformColor,
+ );
+ } else {
+ native.BorderThickness = Windows.UI.Xaml.ThicknessHelper.FromUniformLength(
+ layout.toDeviceIndependentPixels(borderWidth)
+ );
+ native.BorderBrush = new Windows.UI.Xaml.Media.SolidColorBrush(borderColor?.windows ?? Windows.UI.Colors.Transparent);
+ }
+
+ } else {
+
+ const leftWidth = layout.toDeviceIndependentPixels(background.borderLeftWidth || 0);
+ const topWidth = layout.toDeviceIndependentPixels(background.borderTopWidth || 0);
+ const rightWidth = layout.toDeviceIndependentPixels(background.borderRightWidth || 0);
+ const bottomWidth = layout.toDeviceIndependentPixels(background.borderBottomWidth || 0);
+
+ if (this._viewCompositionHandler) {
+
+ this._viewCompositionHandler.UpdateBorderWidth(
+ leftWidth, topWidth, rightWidth, bottomWidth,
+ );
+
+ const leftColor = (background.borderLeftColor || borderColor) as WindowsColor;
+ const topColor = (background.borderTopColor || borderColor) as WindowsColor;
+ const rightColor = (background.borderRightColor || borderColor) as WindowsColor;
+ const bottomColor = (background.borderBottomColor || borderColor) as WindowsColor;
+
+
+ this._viewCompositionHandler.UpdateBorderColor(
+ leftColor?.windowsArgb ?? 0, topColor?.windowsArgb ?? 0, rightColor?.windowsArgb ?? 0, bottomColor?.windowsArgb ?? 0,
+ );
+
+ } else {
+ // per-side border thickness is not directly supported in XAML
+ native.BorderThickness = Windows.UI.Xaml.ThicknessHelper.FromLengths(leftWidth, topWidth, rightWidth, bottomWidth);
+ }
+
+ }
+
+
+
+ this._nativeBackgroundState = 'drawn';
+
+ if (this._viewCompositionHandler) {
+ const hasShadow = background && typeof background.hasBoxShadows === 'function' && background.hasBoxShadows();
+ if (hasShadow) {
+ const boxShadows = typeof background.getBoxShadows === 'function' ? background.getBoxShadows() : background.boxShadows;
+ const s = boxShadows?.length ? boxShadows[boxShadows.length - 1] : null;
+ this._viewCompositionHandler.UpdateBoxShadow(s);
+ } else {
+ this._viewCompositionHandler.UpdateBoxShadow(null);
+ }
+ }
+
+ }
+
+ initNativeView(): void {
+ super.initNativeView();
+ const ref = new WeakRef(this);
+ this.nativeViewProtected.LayoutUpdated = () => {
+ const owner = ref.deref();
+ if (!owner) return;
+ owner._onSizeChanged();
+ }
+ }
+
+ private _easeOutCubic(t: number) {
+ return 1 - Math.pow(1 - t, 3);
+ }
+
+ private _animateNativeOpacity(nativeElem: any, from: number, to: number, durationMs: number, done?: () => void) {
+ try {
+ nativeElem.Opacity = from;
+ } catch (_e) { }
+
+ const start = Date.now();
+ const step = () => {
+ const now = Date.now();
+ const elapsed = now - start;
+ const t = Math.min(1, elapsed / Math.max(1, durationMs));
+ const val = from + (to - from) * this._easeOutCubic(t);
+ try { nativeElem.Opacity = val; } catch (_e) { }
+ if (t < 1) {
+ if (typeof requestAnimationFrame === 'function') {
+ requestAnimationFrame(step as any);
+ } else {
+ setTimeout(step, 16);
+ }
+ } else {
+ done && done();
+ }
+ };
+ step();
+ }
+
+ disposeNativeView(): void {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView) {
+ nativeView.LayoutUpdated = null;
+ }
+ super.disposeNativeView();
+ }
+
+ _onSizeChanged(): void {
+ const nativeView = this.nativeViewProtected;
+ if (!nativeView) {
+ return;
+ }
+
+ // Recompute any percent-based sizing when layout updates.
+ try { this._applyPercentSizing(); } catch (_e) { }
+
+
+ const background = this.style.backgroundInternal;
+ const backgroundDependsOnSize = (background && background.image && background.image !== 'none') || (background && background.clipPath) || (background && !background.hasUniformBorder()) || (background && background.hasBorderRadius && background.hasBorderRadius()) || (background && background.hasBoxShadows && background.hasBoxShadows());
+
+ if (this._nativeBackgroundState === 'invalid' || (this._nativeBackgroundState === 'drawn' && backgroundDependsOnSize)) {
+ this._redrawNativeBackground(background);
+ }
+
+ // Update clip geometry and composition visuals size if needed
+ try {
+ if (nativeView.Clip && nativeView.Clip instanceof Windows.UI.Xaml.Media.RectangleGeometry) {
+ const rectGeom = nativeView.Clip as Windows.UI.Xaml.Media.RectangleGeometry;
+ const w = nativeView.ActualWidth || nativeView.Width || 0;
+ const h = nativeView.ActualHeight || nativeView.Height || 0;
+
+ const location = Windows.UI.Xaml.PointHelper.FromCoordinates(0, 0);
+ const size = Windows.UI.Xaml.SizeHelper.FromDimensions(w, h);
+ rectGeom.Rect = Windows.UI.Xaml.RectHelper.FromLocationAndSize(location, size);
+
+ }
+
+ } catch (_e) { }
+ }
+
+ // Compute and apply percent-based width/height (percent values stored in _percentWidth/_percentHeight)
+ private _applyPercentSizing(): void {
+ const nativeView = this.nativeViewProtected as any;
+ if (!nativeView) {
+ return;
+ }
+
+ try {
+ const parentNative = (this.parent as any)?.nativeViewProtected as any;
+ const parentWidth = parentNative?.ActualWidth || 0;
+ const parentHeight = parentNative?.ActualHeight || 0;
+
+ // Only apply when the parent has a real layout size. Using Window.Bounds as a
+ // fallback when the parent is 0 causes nested views with height="100%" to expand
+ // to full-screen height, overflowing their container and covering sibling rows.
+ // LayoutUpdated fires again once the parent is properly sized, at which point
+ // the correct percent value is applied.
+ if (this._percentWidth != null && parentWidth > 0) {
+ const w = parentWidth * (this._percentWidth);
+ nativeView.Width = isFinite(w) ? w : NaN;
+ }
+
+ if (this._percentHeight != null && parentHeight > 0) {
+ const h = parentHeight * (this._percentHeight);
+ nativeView.Height = isFinite(h) ? h : NaN;
+ }
+ } catch (_e) { }
+ }
+
+ [backgroundInternalProperty.getDefault](): any {
+ const native = this.nativeViewProtected as any;
+ if (!native) return null;
+ try {
+ return native.Background ?? null;
+ } catch (_e) {
+ return null;
+ }
+ }
+
+ private _viewCompositionHandler: any;
+
+ private _modalAnimatedOptions: any[] | undefined;
+
+ [backgroundInternalProperty.setNative](value: any) {
+ this._nativeBackgroundState = 'invalid';
+ this._redrawNativeBackground(value);
+ }
+
+ //@ts-ignore
+ [widthProperty.setNative](value: CoreTypes.PercentLengthType) {
+ if (!this.nativeViewProtected) {
+ return;
+ }
+
+ // Handle percent-based widths specially: store percent and compute on layout updates.
+ if (value && typeof value === 'object' && (value as any).unit === '%') {
+ this._percentWidth = (value as any).value;
+ this.nativeViewProtected.Width = NaN;
+ try { this._applyPercentSizing(); } catch (_e) { }
+ return;
+ }
+
+ this._percentWidth = null;
+ this.nativeViewProtected.Width = toXamlLength(value);
+ }
+
+ //@ts-ignore
+ [heightProperty.setNative](value: CoreTypes.PercentLengthType) {
+ if (!this.nativeViewProtected) {
+ return;
+ }
+
+ if (value && typeof value === 'object' && (value as any).unit === '%') {
+ this._percentHeight = (value as any).value;
+ this.nativeViewProtected.Height = NaN;
+ try { this._applyPercentSizing(); } catch (_e) { }
+ return;
+ }
+
+ this._percentHeight = null;
+ this.nativeViewProtected.Height = toXamlLength(value);
+ }
+
+ //@ts-ignore
+ [minWidthProperty.setNative](value: CoreTypes.LengthType) {
+ if (this.nativeViewProtected) {
+ const v = toXamlLength(value);
+ (this.nativeViewProtected as any).MinWidth = isNaN(v) ? 0 : v;
+ }
+ }
+
+ //@ts-ignore
+ [minHeightProperty.setNative](value: CoreTypes.LengthType) {
+ if (this.nativeViewProtected) {
+ const v = toXamlLength(value);
+ (this.nativeViewProtected as any).MinHeight = isNaN(v) ? 0 : v;
+ }
+ }
+
+ [opacityProperty.setNative](value: number) {
+ if (this.nativeViewProtected) {
+ this.nativeViewProtected.Opacity = value;
+ }
+ }
+
+
+ [hiddenProperty.getDefault](): boolean {
+ return getVisibility(this.nativeViewProtected as any) !== 'visible';
+ }
+
+ [hiddenProperty.setNative](value: boolean) {
+ setVisibility(this.nativeViewProtected as any, value ? 'hidden' : 'visible');
+ }
+
+
+ [visibilityProperty.setNative](value: CoreTypes.VisibilityType) {
+ if (this.nativeViewProtected) {
+ setVisibility(this.nativeViewProtected as any, value);
+ }
+ }
+
+ //@ts-ignore
+ [marginLeftProperty.setNative](_value: CoreTypes.PercentLengthType) {
+ this._applyMargin();
+ }
+ //@ts-ignore
+ [marginTopProperty.setNative](_value: CoreTypes.PercentLengthType) {
+ this._applyMargin();
+ }
+ //@ts-ignore
+ [marginRightProperty.setNative](_value: CoreTypes.PercentLengthType) {
+ this._applyMargin();
+ }
+ //@ts-ignore
+ [marginBottomProperty.setNative](_value: CoreTypes.PercentLengthType) {
+ this._applyMargin();
+ }
+
+ private _applyMargin(): void {
+ if (!this.nativeViewProtected) return;
+ try {
+ const l = toXamlLength(this.style.marginLeft) || 0;
+ const t = toXamlLength(this.style.marginTop) || 0;
+ const r = toXamlLength(this.style.marginRight) || 0;
+ const b = toXamlLength(this.style.marginBottom) || 0;
+ (this.nativeViewProtected as any).Margin = Windows.UI.Xaml.ThicknessHelper.FromLengths(l, t, r, b);
+ } catch (_e) { }
+ }
+
+ //@ts-ignore
+ [paddingTopProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+ //@ts-ignore
+ [paddingRightProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+ //@ts-ignore
+ [paddingBottomProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+ //@ts-ignore
+ [paddingLeftProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+
+ private _applyPadding(): void {
+ const native = this.nativeViewProtected as any;
+ if (!native) return;
+ try {
+ const l = toXamlLength(this.style.paddingLeft) || 0;
+ const t = toXamlLength(this.style.paddingTop) || 0;
+ const r = toXamlLength(this.style.paddingRight) || 0;
+ const b = toXamlLength(this.style.paddingBottom) || 0;
+ native.Padding = Windows.UI.Xaml.ThicknessHelper.FromLengths(l, t, r, b);
+ } catch (_e) { }
+ }
+
+ //@ts-ignore
+ [horizontalAlignmentProperty.setNative](value: CoreTypes.HorizontalAlignmentType) {
+ const native = this.nativeViewProtected as any;
+ if (!native) return;
+ // WinUI HorizontalAlignment: Left=0, Center=1, Right=2, Stretch=3
+ switch (value) {
+ case 'left': native.HorizontalAlignment = 0; break;
+ case 'center': native.HorizontalAlignment = 1; break;
+ case 'right': native.HorizontalAlignment = 2; break;
+ case 'stretch': native.HorizontalAlignment = 3; break;
+ }
+ }
+
+ //@ts-ignore
+ [verticalAlignmentProperty.setNative](value: CoreTypes.VerticalAlignmentTextType) {
+ const native = this.nativeViewProtected as any;
+ if (!native) return;
+ // WinUI VerticalAlignment: Top=0, Center=1, Bottom=2, Stretch=3
+ switch (value) {
+ case 'top': native.VerticalAlignment = 0; break;
+ case 'middle': native.VerticalAlignment = 1; break;
+ case 'center': native.VerticalAlignment = 1; break;
+ case 'bottom': native.VerticalAlignment = 2; break;
+ case 'stretch': native.VerticalAlignment = 3; break;
+ }
+ }
+
+ [originXProperty.getDefault](): number {
+ const native = this.nativeViewProtected as any;
+ if (!native) return 0.5;
+ try {
+ const origin = native.RenderTransformOrigin;
+ return origin ? origin.X ?? 0.5 : 0.5;
+ } catch (_e) {
+ return 0.5;
+ }
+ }
+ [originXProperty.setNative](value: number) {
+ try {
+ const native = this.nativeViewProtected as any;
+ const y = this.originY ?? 0.5;
+ if (native && typeof Windows !== 'undefined' && Windows.UI && Windows.UI.Xaml && Windows.UI.Xaml.PointHelper) {
+ native.RenderTransformOrigin = Windows.UI.Xaml.PointHelper.FromCoordinates(value, y);
+ }
+ } catch (_e) { }
+ }
+
+ [originYProperty.getDefault](): number {
+ const native = this.nativeViewProtected as any;
+ if (!native) return 0.5;
+ try {
+ const origin = native.RenderTransformOrigin;
+ return origin ? origin.Y ?? 0.5 : 0.5;
+ } catch (_e) {
+ return 0.5;
+ }
+ }
+ [originYProperty.setNative](value: number) {
+ try {
+ const native = this.nativeViewProtected as any;
+ const x = this.originX ?? 0.5;
+ if (native && typeof Windows !== 'undefined' && Windows.UI && Windows.UI.Xaml && Windows.UI.Xaml.PointHelper) {
+ native.RenderTransformOrigin = Windows.UI.Xaml.PointHelper.FromCoordinates(x, value);
+ }
+ } catch (_e) { }
+ }
+
+ [rotateProperty.getDefault](): number {
+ return 0;
+ }
+ [rotateProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [rotateXProperty.getDefault](): number {
+ return 0;
+ }
+ [rotateXProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [rotateYProperty.getDefault](): number {
+ return 0;
+ }
+ [rotateYProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [perspectiveProperty.getDefault](): number {
+ return 300;
+ }
+ [perspectiveProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [scaleXProperty.getDefault](): number {
+ return 1;
+ }
+ [scaleXProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [scaleYProperty.getDefault](): number {
+ return 1;
+ }
+ [scaleYProperty.setNative](value: number) {
+ this.updateNativeTransform();
+ }
+
+ [translateXProperty.getDefault](): CoreTypes.dip {
+ return 0;
+ }
+ [translateXProperty.setNative](value: CoreTypes.dip) {
+ this.updateNativeTransform();
+ }
+
+ [translateYProperty.getDefault](): CoreTypes.dip {
+ return 0;
+ }
+ [translateYProperty.setNative](value: CoreTypes.dip) {
+ this.updateNativeTransform();
+ }
+
+ public updateNativeTransform(): void {
+ const native = this.nativeViewProtected as any;
+ if (!native) return;
+ try {
+ const transforms = _ensureNativeTransforms(native);
+ if (!transforms) return;
+
+ const sx = typeof (this as any).scaleX === 'number' ? (this as any).scaleX : typeof (this as any).scale === 'number' ? (this as any).scale : 1;
+ const sy = typeof (this as any).scaleY === 'number' ? (this as any).scaleY : typeof (this as any).scale === 'number' ? (this as any).scale : 1;
+ transforms.scale.ScaleX = sx;
+ transforms.scale.ScaleY = sy;
+
+ transforms.rotate.Angle = (this as any).rotate || 0;
+
+ // translateX/Y are in DIPs — WinUI TranslateTransform also uses DIPs. No conversion.
+ transforms.translate.X = (this as any).translateX || 0;
+ transforms.translate.Y = (this as any).translateY || 0;
+
+ try {
+ const ox = this.originX ?? 0.5;
+ const oy = this.originY ?? 0.5;
+ native.RenderTransformOrigin = Windows.UI.Xaml.PointHelper.FromCoordinates(ox, oy);
+ } catch (_e) { }
+ } catch (_e) {
+ // best-effort
+ }
+ }
+
+ // Simple modal implementation using a Popup overlay
+ private _modalPopup: any;
+ private _modalOverlay: any;
+ private _modalAnimatedOptions: Array;
+ // Saved previous layout/size/alignment for restoring after modal closes
+ private _modalPrevHorizontalAlignment: any;
+ private _modalPrevVerticalAlignment: any;
+ private _modalPrevWidth: number;
+ private _modalPrevHeight: number;
+ private _modalPrevNativeHorizontalAlignment: any;
+ private _modalPrevNativeVerticalAlignment: any;
+ private _modalPrevNativeWidth: any;
+ private _modalPrevNativeHeight: any;
+ private _modalPopupClosedHandler: any;
+ private _isModalClosing: boolean;
+
+ protected _showNativeModalView(parent: ViewCommon, options: any) {
+ // Prepare as root view and call base
+ this._setupAsRootView({});
+ super._showNativeModalView(parent, options);
+
+ this._raiseShowingModallyEvent();
+
+ try {
+ const popup = new Windows.UI.Xaml.Controls.Primitives.Popup();
+ const overlay = new Windows.UI.Xaml.Controls.Grid();
+ overlay.HorizontalAlignment = 3; // Stretch
+ overlay.VerticalAlignment = 3; // Stretch
+ // Transparent background to capture clicks; caller can style the modal's background
+ overlay.Background = new Windows.UI.Xaml.Media.SolidColorBrush(Windows.UI.Colors.Transparent);
+
+ // Ensure overlay fills window (best-effort)
+ try {
+ const bounds = Windows.UI.Xaml.Window.Current.Bounds;
+ overlay.Width = bounds.Width;
+ overlay.Height = bounds.Height;
+ } catch (_e) { }
+
+ // Determine show animation preference early
+ const showAnimated = options && options.animated === undefined ? true : !!options.animated;
+ // Prepare overlay opacity for animation
+ try { overlay.Opacity = showAnimated ? 0 : 1; } catch (_e) { }
+
+ // Host the modal native element inside overlay
+ try {
+ // Save previous alignment/size to restore later
+ try {
+ this._modalPrevHorizontalAlignment = this.horizontalAlignment;
+ this._modalPrevVerticalAlignment = this.verticalAlignment;
+ this._modalPrevWidth = this.width;
+ this._modalPrevHeight = this.height;
+ try {
+ this._modalPrevNativeHorizontalAlignment = (this.nativeViewProtected as any).HorizontalAlignment;
+ this._modalPrevNativeVerticalAlignment = (this.nativeViewProtected as any).VerticalAlignment;
+ this._modalPrevNativeWidth = (this.nativeViewProtected as any).Width;
+ this._modalPrevNativeHeight = (this.nativeViewProtected as any).Height;
+ } catch (_e) { }
+ } catch (_e) { }
+
+ const isStretch = options && (options.fullscreen || options.stretched);
+
+ if (isStretch) {
+ this.horizontalAlignment = 'stretch';
+ this.verticalAlignment = 'stretch';
+ try {
+ (this.nativeViewProtected as any).HorizontalAlignment = 3; // Stretch
+ (this.nativeViewProtected as any).VerticalAlignment = 3; // Stretch
+ // If fullscreen, make it fill window bounds
+ try {
+ const bounds = Windows.UI.Xaml.Window.Current.Bounds;
+ this.width = bounds.Width;
+ this.height = bounds.Height;
+ (this.nativeViewProtected as any).Width = bounds.Width;
+ (this.nativeViewProtected as any).Height = bounds.Height;
+ } catch (_e) { }
+ } catch (_e) { }
+ } else {
+ this.horizontalAlignment = 'center';
+ this.verticalAlignment = 'middle';
+ try {
+ (this.nativeViewProtected as any).HorizontalAlignment = 1; // Center
+ (this.nativeViewProtected as any).VerticalAlignment = 1; // Center
+ } catch (_e) { }
+
+ // Honor width/height if provided (top-level or ios-specific)
+ try {
+ const w = options && typeof options.width === 'number' ? options.width : options && options.ios && typeof options.ios.width === 'number' ? options.ios.width : undefined;
+ const h = options && typeof options.height === 'number' ? options.height : options && options.ios && typeof options.ios.height === 'number' ? options.ios.height : undefined;
+ if (typeof w === 'number' && w > 0) {
+ this.width = w;
+ try { (this.nativeViewProtected as any).Width = w; } catch (_e) { }
+ } else {
+ // allow natural measurement when no explicit width provided
+ this.width = unsetValue;
+ try { (this.nativeViewProtected as any).Width = NaN; } catch (_e) { }
+ }
+ if (typeof h === 'number' && h > 0) {
+ this.height = h;
+ try { (this.nativeViewProtected as any).Height = h; } catch (_e) { }
+ } else {
+ this.height = unsetValue;
+ try { (this.nativeViewProtected as any).Height = NaN; } catch (_e) { }
+ }
+ } catch (_e) { }
+ }
+
+ overlay.Children.Append(this.nativeViewProtected);
+ } catch (_e) { }
+
+ popup.Child = overlay;
+ popup.IsLightDismissEnabled = options && options.cancelable !== undefined ? !!options.cancelable : true;
+ this._modalPopup = popup;
+ this._modalOverlay = overlay;
+
+
+ // Attach Closed handler to forward light-dismiss to modal close logic
+ try {
+ this._modalPopupClosedHandler = () => {
+ if (this._isModalClosing) {
+ return;
+ }
+ if (this._closeModalCallback) {
+ this._closeModalCallback();
+ }
+ };
+ //@ts-ignore
+ popup.AddHandler(Windows.UI.Xaml.Controls.Primitives.Popup.ClosedEvent, this._modalPopupClosedHandler, true);
+
+ } catch (_e) { }
+
+ popup.IsOpen = true;
+
+ // Ensure the modal view lifecycle runs (loaded) so pages and child views initialize
+ try {
+ this.callLoaded();
+ } catch (_e) { }
+
+ const animated = showAnimated;
+ if (!this._modalAnimatedOptions) {
+ this._modalAnimatedOptions = [];
+ }
+ this._modalAnimatedOptions.push(animated);
+ this._raiseShownModallyEvent();
+ // Perform show animation (fade-in)
+ try {
+ if (showAnimated && this._modalOverlay) {
+ this._animateNativeOpacity(this._modalOverlay, 0, 1, 240);
+ }
+ } catch (_e) { }
+ } catch (e) {
+ console.log('[View._showNativeModalView] failed to open popup modal:', e);
+ }
+ }
+
+ protected _hideNativeModalView(_parent: ViewCommon, whenClosedCallback: () => void) {
+ if (this._isModalClosing) {
+ whenClosedCallback();
+ return;
+ }
+ this._isModalClosing = true;
+ try {
+ // Remove Closed handler if attached
+ try {
+ if (this._modalPopup && this._modalPopupClosedHandler && typeof this._modalPopup.removeEventListener === 'function') {
+ try { this._modalPopup.removeEventListener('Closed', this._modalPopupClosedHandler); } catch (_e) { }
+ }
+ } catch (_e) { }
+
+ // Determine whether we should animate closing
+ const animated = this._modalAnimatedOptions && this._modalAnimatedOptions.length ? !!this._modalAnimatedOptions.pop() : true;
+
+ const finalize = () => {
+ // Restore previous alignment/size
+ try {
+ if (this._modalPrevHorizontalAlignment !== undefined) {
+ this.horizontalAlignment = this._modalPrevHorizontalAlignment;
+ }
+ if (this._modalPrevVerticalAlignment !== undefined) {
+ this.verticalAlignment = this._modalPrevVerticalAlignment;
+ }
+ if (this._modalPrevWidth !== undefined) {
+ this.width = this._modalPrevWidth;
+ }
+ if (this._modalPrevHeight !== undefined) {
+ this.height = this._modalPrevHeight;
+ }
+ try {
+ if (this._modalPrevNativeHorizontalAlignment !== undefined) {
+ (this.nativeViewProtected as any).HorizontalAlignment = this._modalPrevNativeHorizontalAlignment;
+ }
+ if (this._modalPrevNativeVerticalAlignment !== undefined) {
+ (this.nativeViewProtected as any).VerticalAlignment = this._modalPrevNativeVerticalAlignment;
+ }
+ if (this._modalPrevNativeWidth !== undefined) {
+ (this.nativeViewProtected as any).Width = this._modalPrevNativeWidth;
+ }
+ if (this._modalPrevNativeHeight !== undefined) {
+ (this.nativeViewProtected as any).Height = this._modalPrevNativeHeight;
+ }
+ } catch (_e) { }
+ } catch (_e) { }
+
+ // Close popup and clear overlay
+ try {
+ if (this._modalPopup) {
+ try { this._modalPopup.IsOpen = false; } catch (_e) { }
+ try { this._modalPopup.Child = null; } catch (_e) { }
+ this._modalPopup = null;
+ }
+ if (this._modalOverlay) {
+ try { this._modalOverlay.Children.Clear(); } catch (_e) { }
+ this._modalOverlay = null;
+ }
+ } catch (_e) { }
+
+ // Reset modal closing flag
+ this._isModalClosing = false;
+
+ whenClosedCallback();
+ };
+
+ if (animated && this._modalOverlay) {
+ try {
+ const from = typeof this._modalOverlay.Opacity === 'number' ? this._modalOverlay.Opacity : 1;
+ this._animateNativeOpacity(this._modalOverlay, from, 0, 240, finalize);
+ } catch (_e) {
+ finalize();
+ }
+ } else {
+ finalize();
+ }
+
+ } catch (_e) { }
+ }
+}
+
+// Default native background state set on prototype for downlevel emitters
+try {
+ (View.prototype as any)._nativeBackgroundState = 'unset';
+} catch (_e) { }
+
+export class ContainerView extends View { }
+
+export class CustomLayoutView extends ContainerView {
+
+ createNativeView() {
+ return new Windows.UI.Xaml.Controls.StackPanel();
+ }
+
+ public _addViewToNativeVisualTree(child: ViewCommon, _atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+ super._addViewToNativeVisualTree(child);
+ const nativeParent = this.nativeViewProtected as any;
+ const nativeChild = child.nativeViewProtected as any;
+ if (nativeParent && nativeChild) {
+ const children = nativeParent.Children;
+ if (children) {
+ const size = children.Size;
+ try {
+ if (_atIndex >= 0 && _atIndex < size && _atIndex < Number.MAX_SAFE_INTEGER) {
+ children.InsertAt(_atIndex, nativeChild);
+ } else {
+ children.Append(nativeChild);
+ }
+ } catch {
+ return false;
+ }
+
+ try { if (!(nativeChild as any).__ns_view) (nativeChild as any).__ns_view = child; } catch (_e) { }
+
+ // Force layout on the appended child in case the runtime deferred measure/arrange
+ try { if (typeof (nativeChild as any).InvalidateMeasure === 'function') (nativeChild as any).InvalidateMeasure(); } catch (_e) { }
+ try { if (typeof (nativeChild as any).InvalidateArrange === 'function') (nativeChild as any).InvalidateArrange(); } catch (_e) { }
+ try { if (typeof (nativeChild as any).UpdateLayout === 'function') (nativeChild as any).UpdateLayout(); } catch (_e) { }
+
+ try { if (typeof nativeParent.UpdateLayout === 'function') nativeParent.UpdateLayout(); } catch (_e) { }
+ try { if (typeof (nativeParent as any).InvalidateMeasure === 'function') (nativeParent as any).InvalidateMeasure(); } catch (_e) { }
+ try { if (typeof (nativeParent as any).InvalidateArrange === 'function') (nativeParent as any).InvalidateArrange(); } catch (_e) { }
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+ const nativeParent = this.nativeViewProtected as any;
+ const nativeChild = child.nativeViewProtected as any;
+
+ if (nativeParent && nativeChild) {
+ const children = nativeParent.Children;
+ if (children) {
+ const count = children.Size;
+ for (let i = 0; i < count; i++) {
+ if (children.GetAt(i) === nativeChild) {
+ children.RemoveAt(i);
+ break;
+ }
+ }
+ }
+ }
+
+ super._removeViewFromNativeVisualTree(child);
+ }
+}
diff --git a/packages/core/ui/core/view/view-helper/index.windows.ts b/packages/core/ui/core/view/view-helper/index.windows.ts
new file mode 100644
index 0000000000..7301b36623
--- /dev/null
+++ b/packages/core/ui/core/view/view-helper/index.windows.ts
@@ -0,0 +1,3 @@
+export * from './view-helper-common';
+export const AndroidHelper = 0;
+export const IOSHelper = 0;
diff --git a/packages/core/ui/date-picker/index.windows.ts b/packages/core/ui/date-picker/index.windows.ts
new file mode 100644
index 0000000000..f58a3c044e
--- /dev/null
+++ b/packages/core/ui/date-picker/index.windows.ts
@@ -0,0 +1,22 @@
+export * from './date-picker-common';
+
+import { DatePickerBase } from './date-picker-common';
+
+export class DatePicker extends DatePickerBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.DatePicker;
+ private _windows: Windows.UI.Xaml.Controls.DatePicker;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.DatePicker();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.DatePicker {
+ return this._windows;
+ }
+}
+
diff --git a/packages/core/ui/dialogs/index.windows.ts b/packages/core/ui/dialogs/index.windows.ts
new file mode 100644
index 0000000000..39d7667255
--- /dev/null
+++ b/packages/core/ui/dialogs/index.windows.ts
@@ -0,0 +1,350 @@
+export * from './dialogs-common';
+
+import { type PromptResult, type LoginResult, type ActionOptions, DialogStrings, isDialogOptions, PromptOptions, inputType, capitalizationType, parseLoginOptions } from './dialogs-common';
+
+function isString(value: any): value is string {
+ return typeof value === 'string';
+}
+
+const letterReg = /\p{L}/u;
+const digitReg = /\p{N}/u;
+const whiteSpaceReg = /\s/;
+
+export const isLetter = (ch: string) => letterReg.test(ch);
+export const isDigit = (ch: string) => digitReg.test(ch);
+export const isWhiteSpace = (ch: string) => whiteSpaceReg.test(ch);
+
+function capitalizeSentences(text: string): string {
+ let result = '';
+ let capitalize = true;
+ let afterPunct = false;
+ let changed = false;
+ for (let i = 0; i < text.length; i++) {
+ const ch = text[i];
+ if (capitalize && isLetter(ch)) {
+ const upper = ch.toUpperCase();
+ if (upper !== ch) changed = true;
+ result += upper;
+ capitalize = false;
+ afterPunct = false;
+ } else {
+ result += ch;
+ if (ch === '.' || ch === '!' || ch === '?') afterPunct = true;
+ else if (afterPunct && isWhiteSpace(ch)) capitalize = true;
+ else if (!isWhiteSpace(ch)) afterPunct = false;
+ }
+ }
+ return changed ? result : text;
+}
+
+function capitalizeWords(text: string): string {
+ let result = '';
+ let capitalize = true;
+ let changed = false;
+ for (let i = 0; i < text.length; i++) {
+ const ch = text[i];
+ if (capitalize && isLetter(ch)) {
+ const upper = ch.toUpperCase();
+ if (upper !== ch) changed = true;
+ result += upper;
+ capitalize = false;
+ } else {
+ result += ch;
+ capitalize = isWhiteSpace(ch);
+ }
+ }
+ return changed ? result : text;
+}
+
+export function alert(arg: any): Promise {
+ const options = !isDialogOptions(arg) ? { title: DialogStrings.ALERT, okButtonText: DialogStrings.OK, message: arg + '' } : arg;
+ const dialog = new Windows.UI.Popups.MessageDialog(options.message, options.title);
+ return NSWinRT.toPromise(dialog.ShowAsync()) as Promise;
+}
+
+export function confirm(arg: any): Promise {
+ return new Promise((resolve, reject) => {
+ const options = !isDialogOptions(arg)
+ ? {
+ title: DialogStrings.CONFIRM,
+ okButtonText: DialogStrings.OK,
+ cancelButtonText: DialogStrings.CANCEL,
+ message: arg + '',
+ }
+ : arg;
+
+ try {
+ const dialog = new Windows.UI.Popups.MessageDialog(options.message, options.title);
+ const commands = dialog.Commands as Windows.Foundation.Collections.IVector;
+
+ const ok = new Windows.UI.Popups.UICommand(options.okButtonText);
+ (ok as any).Invoked = NSWinRT.asDelegate(() => resolve(true));
+ commands.Append(ok);
+
+ const cancel = new Windows.UI.Popups.UICommand(options.cancelButtonText);
+ (cancel as any).Invoked = NSWinRT.asDelegate(() => resolve(false));
+ commands.Append(cancel);
+
+ dialog.DefaultCommandIndex = 0;
+ dialog.CancelCommandIndex = 1;
+
+ NSWinRT.toPromise(dialog.ShowAsync()).catch(reject);
+ } catch (e) {
+ reject(e);
+ }
+ });
+}
+
+export function prompt(...args: any[]): Promise {
+ let options: PromptOptions;
+
+ const defaultOptions = {
+ title: DialogStrings.PROMPT,
+ okButtonText: DialogStrings.OK,
+ cancelButtonText: DialogStrings.CANCEL,
+ inputType: inputType.text,
+ };
+ const arg = args[0];
+ if (args.length === 1) {
+ if (isString(arg)) {
+ options = defaultOptions;
+ options.message = arg;
+ } else {
+ options = arg;
+ }
+ } else if (args.length === 2) {
+ if (isString(arg) && isString(args[1])) {
+ options = defaultOptions;
+ options.message = arg;
+ options.defaultText = args[1];
+ }
+ }
+
+ return new Promise((resolve, reject) => {
+ try {
+ const inputDialog = new Windows.UI.Xaml.Controls.ContentDialog();
+ (inputDialog as any).Title = options?.title ?? '';
+
+ const stack = new Windows.UI.Xaml.Controls.StackPanel();
+ const children = (stack as any).Children as Windows.Foundation.Collections.IVector;
+
+ if (options?.message) {
+ const msg = new Windows.UI.Xaml.Controls.TextBlock();
+ (msg as any).Text = options.message;
+ (msg as any).TextWrapping = 2; // WrapWholeWords
+ children.Append(msg);
+ }
+
+ let input: Windows.UI.Xaml.Controls.Control;
+ if (options?.inputType === inputType.password) {
+ const pwd = new Windows.UI.Xaml.Controls.PasswordBox();
+ (pwd as any).PlaceholderText = options.message ?? '';
+ if (isString(options.defaultText)) (pwd as any).Password = options.defaultText;
+ input = pwd;
+ } else {
+ const ctrl = new Windows.UI.Xaml.Controls.TextBox();
+ (ctrl as any).PlaceholderText = options?.message ?? '';
+ if (isString(options?.defaultText)) (ctrl as any).Text = options.defaultText;
+
+ try {
+ let scopeValue: number | undefined;
+ if (options?.inputType === inputType.email) scopeValue = 7; // EmailSmtpAddress
+ else if (options?.inputType === inputType.number) scopeValue = 29; // Number
+ else if (options?.inputType === inputType.decimal) scopeValue = 8; // Digits
+ else if (options?.inputType === inputType.phone) scopeValue = 3; // TelephoneNumber
+
+ if (scopeValue !== undefined) {
+ const scope = new Windows.UI.Xaml.Input.InputScope();
+ const scopeName = new Windows.UI.Xaml.Input.InputScopeName();
+ (scopeName as any).NameValue = scopeValue;
+ ((scope as any).Names as Windows.Foundation.Collections.IVector).Append(scopeName);
+ (ctrl as any).InputScope = scope;
+ }
+ } catch (_e) {}
+
+ try {
+ switch (options?.capitalizationType) {
+ case capitalizationType.all:
+ (ctrl as any).CharacterCasing = 1; // Upper
+ break;
+ case capitalizationType.sentences: {
+ let updatingSentences = false;
+ (ctrl as any).TextChanged = NSWinRT.asDelegate('Windows.UI.Xaml.Controls.TextChangedEventHandler', (s: any) => {
+ if (updatingSentences) return;
+ const text: string = s?.Text;
+ if (!text) return;
+ const transformed = capitalizeSentences(text);
+ if (transformed !== text) {
+ updatingSentences = true;
+ const sel = s.SelectionStart;
+ s.Text = transformed;
+ s.SelectionStart = sel;
+ updatingSentences = false;
+ }
+ });
+ break;
+ }
+ case capitalizationType.words: {
+ let updatingWords = false;
+ (ctrl as any).TextChanged = NSWinRT.asDelegate('Windows.UI.Xaml.Controls.TextChangedEventHandler', (s: any) => {
+ if (updatingWords) return;
+ const text: string = s?.Text;
+ if (!text) return;
+ const transformed = capitalizeWords(text);
+ if (transformed !== text) {
+ updatingWords = true;
+ const sel = s.SelectionStart;
+ s.Text = transformed;
+ s.SelectionStart = sel;
+ updatingWords = false;
+ }
+ });
+ break;
+ }
+ }
+ } catch (_e) {}
+
+ input = ctrl;
+ }
+
+ children.Append(input);
+ (inputDialog as any).Content = stack;
+ (inputDialog as any).PrimaryButtonText = options?.okButtonText ?? DialogStrings.OK;
+ (inputDialog as any).CloseButtonText = options?.cancelButtonText ?? DialogStrings.CANCEL;
+
+ (inputDialog as any).PrimaryButtonClick = NSWinRT.asDelegate(() => {
+ const text = input instanceof Windows.UI.Xaml.Controls.TextBox
+ ? (input as any).Text
+ : (input as any).Password;
+ resolve({ result: true, text: text ?? '' });
+ });
+ (inputDialog as any).CloseButtonClick = NSWinRT.asDelegate(() => {
+ resolve({ result: false, text: '' });
+ });
+
+ NSWinRT.toPromise((inputDialog as any).ShowAsync()).catch(reject);
+ } catch (e) {
+ reject(e);
+ }
+ });
+}
+
+export function login(...args: any[]): Promise {
+ const options = parseLoginOptions(args);
+
+ return new Promise((resolve, reject) => {
+ try {
+ const dialog = new Windows.UI.Xaml.Controls.ContentDialog();
+ (dialog as any).Title = options.title ?? DialogStrings.LOGIN;
+
+ const stack = new Windows.UI.Xaml.Controls.StackPanel();
+ const children = (stack as any).Children as Windows.Foundation.Collections.IVector;
+
+ const userNameBox = new Windows.UI.Xaml.Controls.TextBox();
+ (userNameBox as any).PlaceholderText = options.userNameHint ?? '';
+ (userNameBox as any).Text = isString(options.userName) ? options.userName : '';
+ children.Append(userNameBox);
+
+ const passwordBox = new Windows.UI.Xaml.Controls.PasswordBox();
+ (passwordBox as any).PlaceholderText = options.passwordHint ?? '';
+ (passwordBox as any).Password = isString(options.password) ? options.password : '';
+ children.Append(passwordBox);
+
+ (dialog as any).Content = stack;
+ (dialog as any).PrimaryButtonText = options.okButtonText ?? DialogStrings.OK;
+ (dialog as any).CloseButtonText = options.cancelButtonText ?? DialogStrings.CANCEL;
+
+ (dialog as any).PrimaryButtonClick = NSWinRT.asDelegate(() => {
+ resolve({ result: true, userName: (userNameBox as any).Text, password: (passwordBox as any).Password });
+ });
+ (dialog as any).CloseButtonClick = NSWinRT.asDelegate(() => {
+ resolve({ result: false, userName: '', password: '' });
+ });
+
+ NSWinRT.toPromise((dialog as any).ShowAsync()).catch(reject);
+ } catch (e) {
+ reject(e);
+ }
+ });
+}
+
+export function action(...args: any[]): Promise {
+ let options: ActionOptions;
+
+ const defaultOptions: ActionOptions = { title: undefined, cancelButtonText: DialogStrings.CANCEL };
+
+ if (args.length === 1) {
+ if (isString(args[0])) {
+ options = { ...defaultOptions, message: args[0] };
+ } else {
+ options = args[0];
+ }
+ } else if (args.length === 2) {
+ if (isString(args[0]) && isString(args[1])) {
+ options = { ...defaultOptions, message: args[0], cancelButtonText: args[1] };
+ }
+ } else if (args.length === 3) {
+ if (isString(args[0]) && isString(args[1])) {
+ options = { ...defaultOptions, message: args[0], cancelButtonText: args[1], actions: args[2] };
+ }
+ }
+
+ return new Promise((resolve, reject) => {
+ try {
+ const dialog = new Windows.UI.Xaml.Controls.ContentDialog();
+ if (options.title) (dialog as any).Title = options.title;
+
+ const stack = new Windows.UI.Xaml.Controls.StackPanel();
+ const children = (stack as any).Children as Windows.Foundation.Collections.IVector;
+
+ if (options.message) {
+ const msg = new Windows.UI.Xaml.Controls.TextBlock();
+ (msg as any).Text = options.message;
+ children.Append(msg);
+ }
+
+ let resolved = false;
+ if (options.actions) {
+ for (const actionTitle of options.actions) {
+ if (!isString(actionTitle)) continue;
+ const btn = new Windows.UI.Xaml.Controls.Button();
+ (btn as any).Content = actionTitle;
+ (btn as any).HorizontalAlignment = 3; // Stretch
+ const handler = NSWinRT.asDelegate(() => {
+ if (!resolved) {
+ resolved = true;
+ resolve(actionTitle);
+ (dialog as any).Hide();
+ }
+ });
+ (btn as any).Click = handler;
+ children.Append(btn);
+ }
+ }
+
+ (dialog as any).Content = stack;
+
+ if (isString(options.cancelButtonText)) {
+ (dialog as any).CloseButtonText = options.cancelButtonText;
+ (dialog as any).CloseButtonClick = NSWinRT.asDelegate(() => {
+ if (!resolved) {
+ resolved = true;
+ resolve(options.cancelButtonText ?? '');
+ }
+ });
+ }
+
+ NSWinRT.toPromise((dialog as any).ShowAsync()).catch(reject);
+ } catch (e) {
+ reject(e);
+ }
+ });
+}
+
+export const Dialogs = {
+ alert,
+ confirm,
+ prompt,
+ login,
+ action,
+};
diff --git a/packages/core/ui/editable-text-base/index.windows.ts b/packages/core/ui/editable-text-base/index.windows.ts
new file mode 100644
index 0000000000..2477053d03
--- /dev/null
+++ b/packages/core/ui/editable-text-base/index.windows.ts
@@ -0,0 +1,81 @@
+export * from './editable-text-base-common';
+
+import { EditableTextBase as EditableTextBaseCommon, autofillTypeProperty, keyboardTypeProperty, returnKeyTypeProperty, editableProperty, autocapitalizationTypeProperty, autocorrectProperty, hintProperty, placeholderColorProperty, maxLengthProperty } from './editable-text-base-common';
+import { View } from '../core/view';
+
+export * from './editable-text-base-common';
+
+export abstract class EditableTextBase extends EditableTextBaseCommon {
+ public nativeViewProtected: Windows.UI.Xaml.Controls.TextBox | Windows.UI.Xaml.Controls.PasswordBox;
+
+ public dismissSoftInput() {
+ try {
+ if (this.nativeViewProtected) {
+ (this.nativeViewProtected as any).IsEnabled = false;
+ (this.nativeViewProtected as any).IsEnabled = true;
+ }
+ } catch (_e) {}
+ }
+
+ public focus(): boolean {
+ const result = super.focus();
+ try {
+ if (result && this.nativeViewProtected && typeof (this.nativeViewProtected as any).Focus === 'function') {
+ (this.nativeViewProtected as any).Focus(Windows.UI.Xaml.FocusState.Programmatic);
+ }
+ } catch (_e) {}
+
+ return result;
+ }
+
+ [keyboardTypeProperty.getDefault](): string {
+ // No reliable cross-platform default; return empty
+ return '';
+ }
+ [keyboardTypeProperty.setNative](_value: string) {
+ // Handled by TextField implementation using InputScope
+ }
+
+ [autofillTypeProperty.setNative](_value: any) {
+ // UWP autofill is limited; no-op
+ }
+
+ [returnKeyTypeProperty.getDefault]() {
+ return 'done';
+ }
+ [returnKeyTypeProperty.setNative](_value: any) {
+ // No-op on Windows TextBox
+ }
+
+ [editableProperty.setNative](value: boolean) {
+ try {
+ if (this.nativeViewProtected && typeof (this.nativeViewProtected as any).IsReadOnly !== 'undefined') {
+ (this.nativeViewProtected as any).IsReadOnly = !value;
+ }
+ } catch (_e) {}
+ }
+
+ [autocapitalizationTypeProperty.setNative](_value: any) {
+ // No direct equivalent on Windows TextBox
+ }
+
+ [autocorrectProperty.setNative](_value: any) {
+ // No direct equivalent on Windows TextBox
+ }
+
+ [hintProperty.setNative](value: string) {
+ try {
+ if (this.nativeViewProtected && typeof (this.nativeViewProtected as any).PlaceholderText !== 'undefined') {
+ (this.nativeViewProtected as any).PlaceholderText = value ?? '';
+ }
+ } catch (_e) {}
+ }
+
+ [maxLengthProperty.setNative](value: number) {
+ try {
+ if (this.nativeViewProtected && typeof (this.nativeViewProtected as any).MaxLength !== 'undefined') {
+ (this.nativeViewProtected as any).MaxLength = value ?? 0;
+ }
+ } catch (_e) {}
+ }
+}
diff --git a/packages/core/ui/embedding/index.windows.ts b/packages/core/ui/embedding/index.windows.ts
new file mode 100644
index 0000000000..c368298952
--- /dev/null
+++ b/packages/core/ui/embedding/index.windows.ts
@@ -0,0 +1,3 @@
+export function isEmbedded(): boolean {
+ return false;
+}
diff --git a/packages/core/ui/frame/index.windows.ts b/packages/core/ui/frame/index.windows.ts
new file mode 100644
index 0000000000..bdb74a3b15
--- /dev/null
+++ b/packages/core/ui/frame/index.windows.ts
@@ -0,0 +1,313 @@
+import type { BackstackEntry } from './frame-common';
+import { FrameBase, NavigationType } from './frame-common';
+import { profile } from '../../profiling';
+import type { Page } from '../page';
+
+export * from './frame-common';
+
+export class Frame extends FrameBase {
+ declare nativeViewProtected: any; // Windows.UI.Xaml.Controls.Grid container
+ // _pageHost is a single-cell Grid used to host the current page by appending it as a child.
+ // Using Grid.Children.Append() rather than ContentControl.Content avoids template/binding issues.
+ private _pageHost: any; // Windows.UI.Xaml.Controls.Grid
+ // Keep backward compat alias (_windows) so _navigateCore and _goBackCore work unchanged.
+ private get _windows(): any { return this._pageHost; }
+ private _topBar: any = null;
+ private _backButton: any = null;
+ private _titleBlock: any = null;
+ private _backButtonDelegate: any = null;
+
+ constructor() {
+ super();
+ this._pageHost = new Windows.UI.Xaml.Controls.Grid();
+ }
+
+ public createNativeView(): any {
+ this._buildTopBar();
+ return this._buildContainer();
+ }
+
+ private _buildTopBar(): void {
+ try {
+ this._topBar = new (Windows.UI.Xaml.Controls as any).CommandBar();
+
+ const contentPanel = new Windows.UI.Xaml.Controls.StackPanel();
+ contentPanel.Orientation = Windows.UI.Xaml.Controls.Orientation.Horizontal;
+
+ this._backButton = new Windows.UI.Xaml.Controls.Button();
+ // Use standard left-arrow character (U+2190) — no special font needed
+ (this._backButton as any).Content = '←';
+
+ this._titleBlock = new Windows.UI.Xaml.Controls.TextBlock();
+ (this._titleBlock as any).VerticalAlignment = 1; // Center
+
+ (contentPanel as any).Children.Append(this._backButton);
+ (contentPanel as any).Children.Append(this._titleBlock);
+ (this._topBar as any).Content = contentPanel;
+ (this._topBar as any).Visibility = 1; // Collapsed
+ } catch (_e) {
+ this._topBar = null;
+ }
+ }
+
+ private _buildContainer(): any {
+ if (!this._topBar) {
+ return this._pageHost;
+ }
+
+ // Outer Grid with two rows: row 0 (Auto) for CommandBar, row 1 (*) for page content.
+ try {
+ const outerGrid = new Windows.UI.Xaml.Controls.Grid();
+
+ const autoRow = new Windows.UI.Xaml.Controls.RowDefinition();
+ autoRow.Height = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.auto);
+ const starRow = new Windows.UI.Xaml.Controls.RowDefinition();
+ starRow.Height = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.star);
+ (outerGrid as any).RowDefinitions.Append(autoRow);
+ (outerGrid as any).RowDefinitions.Append(starRow);
+
+ (this._topBar as any).HorizontalAlignment = 3; // Stretch
+ Windows.UI.Xaml.Controls.Grid.SetRow(this._topBar, 0);
+ (outerGrid as any).Children.Append(this._topBar);
+
+ (this._pageHost as any).HorizontalAlignment = 3; // Stretch
+ Windows.UI.Xaml.Controls.Grid.SetRow(this._pageHost, 1);
+ (outerGrid as any).Children.Append(this._pageHost);
+
+ return outerGrid;
+ } catch (_e) {
+ return this._pageHost;
+ }
+ }
+
+ get windows(): any {
+ return this._pageHost;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ this._setupTransitions();
+ this._setupBackButton();
+ }
+
+ private _setupBackButton(): void {
+ if (!this._backButton) return;
+ const that = new WeakRef(this);
+ let usedAdd = false;
+ try {
+ this._backButtonDelegate = new Windows.UI.Xaml.RoutedEventHandler(() => {
+ const owner = that.deref();
+ if (owner?.canGoBack()) owner.goBack();
+ });
+ (this._backButton as any).Click = this._backButtonDelegate as never;
+ } catch (_e) {
+ this._backButtonDelegate = () => {
+ const owner = that.deref();
+ if (owner?.canGoBack()) owner.goBack();
+ };
+ try {
+ (this._backButton as any).Click = this._backButtonDelegate as never;
+ } catch (_e2) {
+ try {
+ if (typeof (this._backButton as any).addEventListener === 'function') {
+ (this._backButton as any).addEventListener('click', this._backButtonDelegate);
+ usedAdd = true;
+ }
+ } catch (_e3) {}
+ }
+ }
+ // store usedAdd if needed in future (not currently tracked)
+ }
+
+ private _setupTransitions(): void {
+ // ContentControl doesn't support ContentTransitions — transitions skipped.
+ }
+
+ //@ts-ignore
+ public setCurrent(entry: BackstackEntry, navigationType: NavigationType): void {
+ const current = this._currentEntry;
+ const currentEntryChanged = current !== entry;
+ if (entry?.resolvedPage && currentEntryChanged) {
+ this._updateBackstack(entry, navigationType);
+ super.setCurrent(entry, navigationType);
+ this._processNavigationQueue(entry.resolvedPage);
+ }
+ }
+
+ @profile
+ public _navigateCore(backstackEntry: BackstackEntry) {
+ super._navigateCore(backstackEntry);
+
+ const navigationType = this._executingContext?.navigationType ?? NavigationType.forward;
+ this.setCurrent(backstackEntry, navigationType);
+
+ const page = backstackEntry.resolvedPage;
+ if (!this._pageHost || !page?.nativeViewProtected) return;
+
+ const isForward = navigationType !== NavigationType.back;
+ const navTransition = (this as any)._getNavigationTransition?.(backstackEntry.entry);
+ const transitionInst = navTransition?.instance;
+ const durMs = (transitionInst?.getDuration?.() ?? 0) * 1000 || 250;
+ const transName: string = transitionInst?.constructor?.name ?? '';
+
+ this._setPageContent(page.nativeViewProtected);
+ if (transName.toLowerCase().includes('slide')) {
+ this._slideIn(page.nativeViewProtected, isForward, durMs);
+ } else if (isForward || transitionInst) {
+ this._fadeIn(page.nativeViewProtected, durMs);
+ }
+ this._updateActionBar(page as Page);
+ }
+
+ private _setPageContent(nativePageView: any): void {
+ const children = this._pageHost.Children as any;
+ if (!children) return;
+ const count = children.Size ?? 0;
+ for (let i = count - 1; i >= 0; i--) {
+ try { children.RemoveAt(i); } catch (_e) {}
+ }
+ children.Append(nativePageView);
+ }
+
+ private _easeOutCubic(t: number): number {
+ return 1 - Math.pow(1 - t, 3);
+ }
+
+ private _animate(durationMs: number, onFrame: (ease: number) => void): void {
+ const start = Date.now();
+ const step = () => {
+ const t = Math.min(1, (Date.now() - start) / Math.max(1, durationMs));
+ onFrame(this._easeOutCubic(t));
+ if (t < 1) {
+ if (typeof requestAnimationFrame === 'function') {
+ requestAnimationFrame(step as any);
+ } else {
+ setTimeout(step, 16);
+ }
+ }
+ };
+ if (typeof requestAnimationFrame === 'function') {
+ requestAnimationFrame(step as any);
+ } else {
+ setTimeout(step, 16);
+ }
+ }
+
+ private _fadeIn(native: any, durationMs: number): void {
+ try { native.Opacity = 0; } catch (_e) { return; }
+ this._animate(durationMs, (ease) => {
+ try { native.Opacity = ease; } catch (_e) {}
+ });
+ }
+
+ private _slideIn(native: any, fromRight: boolean, durationMs: number): void {
+ let tt: any = null;
+ try {
+ tt = new Windows.UI.Xaml.Media.TranslateTransform();
+ tt.X = fromRight ? 320 : -320;
+ native.RenderTransform = tt;
+ } catch (_e) { this._fadeIn(native, durationMs); return; }
+ const startX = tt.X;
+ this._animate(durationMs, (ease) => {
+ try {
+ tt.X = startX * (1 - ease);
+ if (ease >= 1) native.RenderTransform = null;
+ } catch (_e) {}
+ });
+ }
+
+ public _goBackCore(backstackEntry: BackstackEntry) {
+ super._goBackCore(backstackEntry);
+
+ this.setCurrent(backstackEntry, NavigationType.back);
+
+ const page = backstackEntry.resolvedPage;
+ if (!this._pageHost || !page?.nativeViewProtected) return;
+
+ const navTransition = (this as any)._getNavigationTransition?.(backstackEntry.entry);
+ const transitionInst = navTransition?.instance;
+ const durMs = (transitionInst?.getDuration?.() ?? 0) * 1000 || 250;
+ const transName: string = transitionInst?.constructor?.name ?? '';
+
+ this._setPageContent(page.nativeViewProtected);
+ if (transName.toLowerCase().includes('slide')) {
+ this._slideIn(page.nativeViewProtected, false, durMs);
+ } else {
+ this._fadeIn(page.nativeViewProtected, durMs);
+ }
+ this._updateActionBar(page as Page);
+ }
+
+ public _updateActionBar(page?: Page): void {
+ super._updateActionBar(page);
+ if (!this._topBar) return;
+
+ page = page ?? (this.currentPage as Page);
+ if (!page) return;
+
+ const visible = this._isNavBarVisible(page);
+ (this._topBar as any).Visibility = visible ? 0 : 1;
+
+ if (!visible) return;
+
+ if (this._backButton) {
+ const navBtn = (page as any).actionBar?.navigationButton;
+ if (navBtn?.text) {
+ (this._backButton as any).Content = navBtn.text;
+ }
+ (this._backButton as any).Visibility = this.canGoBack() ? 0 : 1;
+ }
+
+ if (this._titleBlock) {
+ (this._titleBlock as any).Text = (page as any).actionBar?.title ?? '';
+ }
+
+ this._rebuildActionItems(page);
+ }
+
+ private _isNavBarVisible(page: Page): boolean {
+ if (this.actionBarVisibility === 'always') return true;
+ if (this.actionBarVisibility === 'never') return false;
+ if ((page as any).actionBarHidden) return false;
+ return !(page as any).actionBar?._isEmpty() || this.canGoBack();
+ }
+
+ private _rebuildActionItems(page: Page): void {
+ try {
+ const commands = (this._topBar as any).PrimaryCommands;
+ commands.Clear();
+ const items: any[] = (page as any).actionBar?.actionItems?.getVisibleItems() ?? [];
+ for (const item of items) {
+ try {
+ const btn = new (Windows.UI.Xaml.Controls as any).AppBarButton();
+ (btn as any).Label = item.text ?? '';
+ let delegate: any = null;
+ let usedAddListener = false;
+ try {
+ delegate = new Windows.UI.Xaml.RoutedEventHandler(() => item._raiseTap());
+ (btn as any).Click = delegate as never;
+ } catch (_e) {
+ delegate = () => item._raiseTap();
+ try {
+ (btn as any).Click = delegate as never;
+ } catch (_e2) {
+ try {
+ if (typeof (btn as any).addEventListener === 'function') {
+ (btn as any).addEventListener('click', delegate);
+ usedAddListener = true;
+ }
+ } catch (_e3) {}
+ }
+ }
+ commands.Append(btn);
+ } catch (_e) {}
+ }
+ } catch (_e) {}
+ }
+}
+
+// attach on global, so it can be overwritten in NativeScript Angular
+global.__onLiveSyncCore = Frame.reloadPage;
+
+export function setActivityCallbacks(_callbacks: any): void {}
+export function setWindowContent(_view: any): void {}
\ No newline at end of file
diff --git a/packages/core/ui/gestures/index.windows.ts b/packages/core/ui/gestures/index.windows.ts
new file mode 100644
index 0000000000..b972837248
--- /dev/null
+++ b/packages/core/ui/gestures/index.windows.ts
@@ -0,0 +1,524 @@
+export * from './gestures-common';
+export * from './gestures-types';
+export * from './touch-manager';
+
+import { GesturesObserverBase, GestureTypes, GestureEvents, GestureStateTypes, toString } from './gestures-common';
+import type { View } from '../core/view';
+import { layout } from '../../utils/layout-helper';
+import * as timer from '../../timer';
+
+// Per-view hover tracking to enable CSS :hover pseudo-class.
+const _hoverViews = new WeakSet();
+
+function _attachHoverHandlers(view: View): void {
+ const native = (view as any).nativeViewProtected as any;
+ if (!native || native.__ns_hover_attached) return;
+
+ const onEnter = () => {
+ if (_hoverViews.has(view)) return;
+ _hoverViews.add(view);
+ try { (view as any)._addVisualState?.('hover'); } catch (_e) { }
+ try { (view as any).notify?.({ eventName: 'mouseEnter', object: view }); } catch (_e) { }
+ };
+ const onLeave = () => {
+ if (!_hoverViews.has(view)) return;
+ _hoverViews.delete(view);
+ try { (view as any)._removeVisualState?.('hover'); } catch (_e) { }
+ try { (view as any).notify?.({ eventName: 'mouseLeave', object: view }); } catch (_e) { }
+ };
+
+ const enterDelegate = _wrapPointerHandler(onEnter);
+ const leaveDelegate = _wrapPointerHandler(onLeave);
+
+ let usingAddHandler = false;
+ try {
+ const pee = native.PointerEnteredEvent;
+ const pxe = native.PointerExitedEvent;
+ if (!pee || !pxe) throw new Error('RoutedEvent properties unavailable');
+ native.AddHandler(pee, enterDelegate, true);
+ native.AddHandler(pxe, leaveDelegate, true);
+ usingAddHandler = true;
+ } catch (_e) {
+ try {
+ _assignPointerHandler(native, 'PointerEntered', enterDelegate);
+ _assignPointerHandler(native, 'PointerExited', leaveDelegate);
+ } catch (_e2) { }
+ }
+
+ native.__ns_hover_attached = true;
+ native.__ns_hover_using_add_handler = usingAddHandler;
+ native.__ns_hover_enter_fn = onEnter;
+ native.__ns_hover_leave_fn = onLeave;
+ native.__ns_hover_enter_delegate = enterDelegate;
+ native.__ns_hover_leave_delegate = leaveDelegate;
+}
+
+function _detachHoverHandlers(view: View): void {
+ const native = (view as any).nativeViewProtected as any;
+ if (!native || !native.__ns_hover_attached) return;
+
+ if (native.__ns_hover_using_add_handler) {
+ try {
+ if (native.__ns_hover_enter_delegate) native.RemoveHandler(native.PointerEnteredEvent, native.__ns_hover_enter_delegate);
+ if (native.__ns_hover_leave_delegate) native.RemoveHandler(native.PointerExitedEvent, native.__ns_hover_leave_delegate);
+ } catch (_e) { }
+ }
+
+ native.__ns_hover_attached = false;
+ native.__ns_hover_using_add_handler = false;
+ native.__ns_hover_enter_fn = null;
+ native.__ns_hover_leave_fn = null;
+ native.__ns_hover_enter_delegate = null;
+ native.__ns_hover_leave_delegate = null;
+ _hoverViews.delete(view);
+}
+
+/** Returns true if the view is currently in a hover state (mouse over). */
+export function isHovered(view: View): boolean {
+ return _hoverViews.has(view);
+}
+
+const DOUBLE_TAP_TIMEOUT = 300;
+const LONG_PRESS_TIMEOUT = 500;
+const TAP_SLOP = 20; // pixels
+
+function _wrapPointerHandler(fn: (s: any, e: any) => void): any {
+ try {
+ return new Windows.UI.Xaml.Input.PointerEventHandler(fn);
+ } catch (_e) {
+ return fn;
+ }
+}
+
+function _wrapRightTappedHandler(fn: (s: any, e: any) => void): any {
+ try {
+ return new Windows.UI.Xaml.Input.RightTappedEventHandler(fn);
+ } catch (_e) {
+ return fn;
+ }
+}
+
+function _assignPointerHandler(native: any, prop: string, fn: (s: any, e: any) => void): void {
+ try { native[prop] = _wrapPointerHandler(fn) as never; } catch (_e) { }
+}
+
+function _assignRightTappedHandler(native: any, fn: (s: any, e: any) => void): void {
+ try { native.RightTapped = _wrapRightTappedHandler(fn) as never; } catch (_e) { }
+}
+
+function _executeCallback(observer: GesturesObserver, args: any) {
+ if (observer && observer.callback) {
+ observer.callback.call(observer.context, args);
+ }
+}
+
+class WindowsPointer {
+ public id: number;
+ private event: any;
+ constructor(id: number, event: any) {
+ this.id = id;
+ this.event = event;
+ }
+ getX(): number {
+ try {
+ const p = extractPoint(this.event);
+ return p.x ?? 0;
+ } catch (_e) {
+ return 0;
+ }
+ }
+ getY(): number {
+ try {
+ const p = extractPoint(this.event);
+ return p.y ?? 0;
+ } catch (_e) {
+ return 0;
+ }
+ }
+}
+
+function extractPoint(e: any, relativeTo?: any) {
+ try {
+ if (e.getCurrentPoint) {
+ const pt = e.getCurrentPoint(relativeTo || null);
+ // PointerPoint may expose Position or position
+ const pos = pt.Position || pt.position || pt; // fallback
+ return { x: pos.X ?? pos.x ?? (pos.Position && pos.Position.X) ?? 0, y: pos.Y ?? pos.y ?? (pos.Position && pos.Position.Y) ?? 0 };
+ }
+ } catch (_e) { }
+
+ try {
+ // some runtimes expose currentPoint
+ const cp = e.currentPoint || e.CurrentPoint;
+ if (cp) {
+ const pos = cp.Position || cp.position || cp;
+ return { x: pos.X ?? pos.x ?? 0, y: pos.Y ?? pos.y ?? 0 };
+ }
+ } catch (_e) { }
+
+ try {
+ if (e.clientX !== undefined && e.clientY !== undefined) {
+ return { x: e.clientX, y: e.clientY };
+ }
+ } catch (_e) { }
+
+ return { x: 0, y: 0 };
+}
+
+export class GesturesObserver extends GesturesObserverBase {
+ private _onTargetLoaded: () => void;
+ private _onTargetUnloaded: () => void;
+
+ private _pointerPressedHandler: any;
+ private _pointerMovedHandler: any;
+ private _pointerReleasedHandler: any;
+ private _pointerCanceledHandler: any;
+ private _rightTappedHandler: any;
+
+ // Wrapped WinRT delegates (needed for RemoveHandler calls)
+ private _pointerPressedDelegate: any;
+ private _pointerMovedDelegate: any;
+ private _pointerReleasedDelegate: any;
+ private _rightTappedDelegate: any;
+ private _usingAddHandler = false;
+
+ private _pointerDownMap: Map = new Map();
+ private _lastUpTime = 0;
+ private _tapTimeoutId: any;
+ private _longPressTimeouts: Map = new Map();
+
+ public observe(type: GestureTypes) {
+ this.type = type;
+
+ if (!this.target) {
+ return;
+ }
+
+ this._onTargetLoaded = () => this._attach(this.target, type);
+ this._onTargetUnloaded = () => this._detach();
+
+ this.target.on('loaded', this._onTargetLoaded);
+ this.target.on('unloaded', this._onTargetUnloaded);
+
+ if (this.target.isLoaded) {
+ this._attach(this.target, type);
+ }
+ }
+
+ public disconnect() {
+ this._detach();
+
+ if (this.target) {
+ this.target.off('loaded', this._onTargetLoaded);
+ this.target.off('unloaded', this._onTargetUnloaded);
+
+ this._onTargetLoaded = null;
+ this._onTargetUnloaded = null;
+ }
+
+ super.disconnect();
+ }
+
+ private _detach() {
+ try {
+ const native = (this.target && (this.target as any).nativeViewProtected) as any;
+ if (native) {
+ if (this._usingAddHandler) {
+ try {
+ if (this._pointerPressedDelegate) native.RemoveHandler(native.PointerPressedEvent, this._pointerPressedDelegate);
+ if (this._pointerMovedDelegate) native.RemoveHandler(native.PointerMovedEvent, this._pointerMovedDelegate);
+ if (this._pointerReleasedDelegate) native.RemoveHandler(native.PointerReleasedEvent, this._pointerReleasedDelegate);
+ if (this._rightTappedDelegate) native.RemoveHandler(native.RightTappedEvent, this._rightTappedDelegate);
+ } catch (_e) { }
+ } else {
+ try { native.PointerPressed = null as never; } catch (_e) { }
+ try { native.PointerMoved = null as never; } catch (_e) { }
+ try { native.PointerReleased = null as never; } catch (_e) { }
+ try { native.RightTapped = null as never; } catch (_e) { }
+ }
+ }
+ } catch (_e) { }
+
+ if (this.target) {
+ _detachHoverHandlers(this.target);
+ }
+
+ this._pointerPressedHandler = null;
+ this._pointerMovedHandler = null;
+ this._pointerReleasedHandler = null;
+ this._pointerCanceledHandler = null;
+ this._rightTappedHandler = null;
+ this._pointerPressedDelegate = null;
+ this._pointerMovedDelegate = null;
+ this._pointerReleasedDelegate = null;
+ this._rightTappedDelegate = null;
+ this._usingAddHandler = false;
+ this._pointerDownMap.clear();
+ this._longPressTimeouts.forEach((id) => timer.clearTimeout(id));
+ this._longPressTimeouts.clear();
+ if (this._tapTimeoutId) {
+ timer.clearTimeout(this._tapTimeoutId);
+ this._tapTimeoutId = null;
+ }
+ }
+
+ private _attach(target: View, type: GestureTypes) {
+ this._detach();
+
+ const native = (target as any).nativeViewProtected as any;
+ if (!native) {
+ return;
+ }
+
+ this._pointerPressedHandler = (s: any, e: any) => this._onPointerPressed(e || s);
+ this._pointerMovedHandler = (s: any, e: any) => this._onPointerMoved(e || s);
+ this._pointerReleasedHandler = (s: any, e: any) => this._onPointerReleased(e || s);
+
+ this._pointerPressedDelegate = _wrapPointerHandler(this._pointerPressedHandler);
+ this._pointerMovedDelegate = _wrapPointerHandler(this._pointerMovedHandler);
+ this._pointerReleasedDelegate = _wrapPointerHandler(this._pointerReleasedHandler);
+
+ // Use AddHandler with handledEventsToo=true so events fire even when
+ // Button (and other controls) mark pointer events as handled internally.
+ // Access RoutedEvent via instance property (not abstract class static) for V8 projection compatibility.
+ this._usingAddHandler = false;
+ try {
+ const ppe = native.PointerPressedEvent;
+ const pme = native.PointerMovedEvent;
+ const pre = native.PointerReleasedEvent;
+ if (!ppe || !pme || !pre) throw new Error('RoutedEvent statics unavailable: ppe=' + ppe + ' pme=' + pme + ' pre=' + pre);
+ native.AddHandler(ppe, this._pointerPressedDelegate, true);
+ native.AddHandler(pme, this._pointerMovedDelegate, true);
+ native.AddHandler(pre, this._pointerReleasedDelegate, true);
+ this._usingAddHandler = true;
+ } catch (_e) {
+ console.warn('[Gestures] AddHandler path failed, using property assignment fallback:', _e && (_e as any).message);
+ _assignPointerHandler(native, 'PointerPressed', this._pointerPressedHandler);
+ _assignPointerHandler(native, 'PointerMoved', this._pointerMovedHandler);
+ _assignPointerHandler(native, 'PointerReleased', this._pointerReleasedHandler);
+ }
+
+ // RightTapped (mouse right-click) fires longPress for mouse/touchpad users.
+ if (type === GestureTypes.longPress) {
+ this._rightTappedHandler = (s: any, e: any) => this._onRightTapped(e || s);
+ this._rightTappedDelegate = _wrapRightTappedHandler(this._rightTappedHandler);
+ try {
+ if (this._usingAddHandler) {
+ const rte = native.RightTappedEvent;
+ if (!rte) throw new Error('RightTappedEvent unavailable');
+ native.AddHandler(rte, this._rightTappedDelegate, true);
+ } else {
+ _assignRightTappedHandler(native, this._rightTappedDelegate);
+ }
+ } catch (_e) { }
+ }
+
+ // Always attach hover handlers for CSS :hover and mouseEnter/mouseLeave events.
+ _attachHoverHandlers(target);
+
+ target.notify({
+ eventName: GestureEvents.gestureAttached,
+ object: target,
+ type: type,
+ view: target,
+ windows: native,
+ });
+ }
+
+ // Required by GesturesObserverDefinition (Android compatibility).
+ public androidOnTouchEvent(_motionEvent: any): void { }
+
+ private _onPointerPressed(e: any) {
+ try {
+ const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+ const pt = extractPoint(e);
+ this._pointerDownMap.set(id, { x: pt.x, y: pt.y, t: Date.now() });
+
+ // schedule long press
+ if (this.type === GestureTypes.longPress) {
+ const timeoutId = timer.setTimeout(() => {
+ const args = {
+ type: GestureTypes.longPress,
+ view: this.target,
+ windows: e,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.longPress),
+ state: GestureStateTypes.began,
+ };
+ _executeCallback(this, args);
+ }, LONG_PRESS_TIMEOUT);
+ this._longPressTimeouts.set(id, timeoutId);
+ }
+
+ if (this.type === GestureTypes.touch) {
+ const args: any = {
+ type: GestureTypes.touch,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.touch),
+ action: 'down',
+ getPointerCount: () => 1,
+ getActivePointers: () => [new WindowsPointer(id, e)],
+ getAllPointers: () => [new WindowsPointer(id, e)],
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+
+ _executeCallback(this, args);
+ }
+ } catch (_e) { }
+ }
+
+ private _onPointerMoved(e: any) {
+ try {
+ const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+ const pt = extractPoint(e);
+ if (this.type === GestureTypes.touch) {
+ const args: any = {
+ type: GestureTypes.touch,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.touch),
+ action: 'move',
+ getPointerCount: () => 1,
+ getActivePointers: () => [new WindowsPointer(id, e)],
+ getAllPointers: () => [new WindowsPointer(id, e)],
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+
+ _executeCallback(this, args);
+ }
+ } catch (_e) { }
+ }
+
+ private _onPointerReleased(e: any) {
+ try {
+ const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+ const pt = extractPoint(e);
+ const start = this._pointerDownMap.get(id);
+ const now = Date.now();
+
+ // clear long press timeout
+ const lp = this._longPressTimeouts.get(id);
+ if (lp) {
+ timer.clearTimeout(lp);
+ this._longPressTimeouts.delete(id);
+ }
+
+ if (this.type === GestureTypes.touch) {
+ const args: any = {
+ type: GestureTypes.touch,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.touch),
+ action: 'up',
+ getPointerCount: () => 1,
+ getActivePointers: () => [new WindowsPointer(id, e)],
+ getAllPointers: () => [new WindowsPointer(id, e)],
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+
+ _executeCallback(this, args);
+ }
+
+ // Try detect tap / doubleTap
+ if (start) {
+ const dt = now - start.t;
+ const dx = pt.x - start.x;
+ const dy = pt.y - start.y;
+ const dist = Math.sqrt(dx * dx + dy * dy);
+
+ if (dt < DOUBLE_TAP_TIMEOUT && dist < TAP_SLOP) {
+ // Possible tap
+ if (this.target.getGestureObservers && this.target.getGestureObservers(GestureTypes.doubleTap) && this.target.getGestureObservers(GestureTypes.doubleTap).length) {
+ // wait for double-tap
+ this._tapTimeoutId = timer.setTimeout(() => {
+ const args = {
+ type: GestureTypes.tap,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.tap),
+ getPointerCount: () => 1,
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+ _executeCallback(this, args);
+ }, DOUBLE_TAP_TIMEOUT);
+ } else {
+ const args = {
+ type: GestureTypes.tap,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.tap),
+ getPointerCount: () => 1,
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+ _executeCallback(this, args);
+ }
+
+ // Double tap detection
+ if (this.target.getGestureObservers && this.target.getGestureObservers(GestureTypes.doubleTap) && this.target.getGestureObservers(GestureTypes.doubleTap).length) {
+ const nowUp = Date.now();
+ if (this._lastUpTime && nowUp - this._lastUpTime <= DOUBLE_TAP_TIMEOUT) {
+ // emit doubleTap
+ const args = {
+ type: GestureTypes.doubleTap,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.doubleTap),
+ getPointerCount: () => 1,
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+ _executeCallback(this, args);
+ }
+ this._lastUpTime = nowUp;
+ }
+ }
+ }
+
+ this._pointerDownMap.delete(id);
+ } catch (_e) { }
+ }
+
+ private _onRightTapped(e: any) {
+ try {
+ const pt = extractPoint(e);
+ const args: any = {
+ type: GestureTypes.longPress,
+ view: this.target,
+ ios: undefined,
+ android: undefined,
+ object: this.target,
+ eventName: toString(GestureTypes.longPress),
+ state: GestureStateTypes.ended,
+ getX: () => pt.x ?? 0,
+ getY: () => pt.y ?? 0,
+ };
+ _executeCallback(this, args);
+ } catch (_e) { }
+ }
+}
+
+export function observe(target: View, type: GestureTypes, callback: (args: any) => void, context?: any): GesturesObserver {
+ const observer = new GesturesObserver(target, callback, context);
+ observer.observe(type);
+ return observer;
+}
diff --git a/packages/core/ui/html-view/index.windows.ts b/packages/core/ui/html-view/index.windows.ts
new file mode 100644
index 0000000000..42207bda9a
--- /dev/null
+++ b/packages/core/ui/html-view/index.windows.ts
@@ -0,0 +1,213 @@
+export * from './html-view-common';
+
+import { Color } from '../../color';
+import { colorProperty, fontInternalProperty } from '../styling/style-properties';
+import { HtmlViewBase, htmlProperty, selectableProperty, linkColorProperty } from './html-view-common';
+
+type HtmlToken =
+ | { kind: 'text'; text: string }
+ | { kind: 'open'; tag: string; attrs: Record }
+ | { kind: 'close'; tag: string }
+ | { kind: 'void'; tag: string };
+
+const VOID_TAGS = new Set(['br', 'hr', 'img', 'input', 'meta', 'link']);
+
+function tokenize(html: string): HtmlToken[] {
+ const tokens: HtmlToken[] = [];
+ const re = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:[^>"']|"[^"]*"|'[^']*')*)(\/?)\s*>/g;
+ let last = 0;
+ let m: RegExpExecArray | null;
+ while ((m = re.exec(html)) !== null) {
+ if (m.index > last) {
+ tokens.push({ kind: 'text', text: html.slice(last, m.index) });
+ }
+ const [, closing, rawTag, attrStr, selfClose] = m;
+ const tag = rawTag.toLowerCase();
+ if (closing) {
+ tokens.push({ kind: 'close', tag });
+ } else if (selfClose || VOID_TAGS.has(tag)) {
+ tokens.push({ kind: 'void', tag });
+ } else {
+ tokens.push({ kind: 'open', tag, attrs: parseAttrs(attrStr) });
+ }
+ last = re.lastIndex;
+ }
+ if (last < html.length) {
+ tokens.push({ kind: 'text', text: html.slice(last) });
+ }
+ return tokens;
+}
+
+function parseAttrs(s: string): Record {
+ const attrs: Record = {};
+ const re = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+ let m: RegExpExecArray | null;
+ while ((m = re.exec(s)) !== null) {
+ attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? '';
+ }
+ return attrs;
+}
+
+function decodeEntities(s: string): string {
+ return s
+ .replace(/&/g, '&')
+ .replace(/</g, '<')
+ .replace(/>/g, '>')
+ .replace(/"/g, '"')
+ .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(+n))
+ .replace(/ /g, ' ');
+}
+
+type InlineParent = Windows.UI.Xaml.Documents.Paragraph | Windows.UI.Xaml.Documents.Span;
+
+function buildParagraphs(html: string, linkColor?: Color): Windows.UI.Xaml.Documents.Paragraph[] {
+ const tokens = tokenize(html);
+ const paragraphs: Windows.UI.Xaml.Documents.Paragraph[] = [];
+ let para = new Windows.UI.Xaml.Documents.Paragraph();
+ paragraphs.push(para);
+ const stack: InlineParent[] = [para];
+
+ const top = () => stack[stack.length - 1];
+
+ function appendInline(inline: Windows.UI.Xaml.Documents.Inline): void {
+ top().Inlines.Append(inline);
+ }
+
+ function pushSpan(span: Windows.UI.Xaml.Documents.Span): void {
+ appendInline(span as unknown as Windows.UI.Xaml.Documents.Inline);
+ stack.push(span);
+ }
+
+ for (const token of tokens) {
+ switch (token.kind) {
+ case 'text': {
+ const text = decodeEntities(token.text);
+ if (text) {
+ const run = new Windows.UI.Xaml.Documents.Run();
+ run.Text = text;
+ appendInline(run);
+ }
+ break;
+ }
+ case 'void':
+ if (token.tag === 'br') {
+ appendInline(new Windows.UI.Xaml.Documents.LineBreak());
+ }
+ break;
+ case 'open':
+ switch (token.tag) {
+ case 'p': {
+ para = new Windows.UI.Xaml.Documents.Paragraph();
+ paragraphs.push(para);
+ stack.length = 1;
+ stack[0] = para;
+ break;
+ }
+ case 'b':
+ case 'strong':
+ pushSpan(new Windows.UI.Xaml.Documents.Bold());
+ break;
+ case 'i':
+ case 'em':
+ pushSpan(new Windows.UI.Xaml.Documents.Italic());
+ break;
+ case 'u':
+ pushSpan(new Windows.UI.Xaml.Documents.Underline());
+ break;
+ case 'a': {
+ const link = new Windows.UI.Xaml.Documents.Hyperlink();
+ const href = (token as { kind: 'open'; tag: string; attrs: Record }).attrs['href'];
+ if (href) {
+ try { link.NavigateUri = new Windows.Foundation.Uri(href); } catch (_) { }
+ }
+ if (linkColor) {
+ link.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(linkColor.windows);
+ }
+ pushSpan(link);
+ break;
+ }
+ case 'span':
+ pushSpan(new Windows.UI.Xaml.Documents.Span());
+ break;
+ }
+ break;
+ case 'close':
+ switch (token.tag) {
+ case 'p': {
+ para = new Windows.UI.Xaml.Documents.Paragraph();
+ paragraphs.push(para);
+ stack.length = 1;
+ stack[0] = para;
+ break;
+ }
+ case 'b':
+ case 'strong':
+ case 'i':
+ case 'em':
+ case 'u':
+ case 'a':
+ case 'span':
+ if (stack.length > 1) stack.pop();
+ break;
+ }
+ break;
+ }
+ }
+
+ const nonEmpty = paragraphs.filter(p => p.Inlines.Size > 0);
+ return nonEmpty.length > 0 ? nonEmpty : [paragraphs[0]];
+}
+
+export class HtmlView extends HtmlViewBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.RichTextBlock;
+
+ public createNativeView() {
+ const nativeView = new Windows.UI.Xaml.Controls.RichTextBlock();
+ nativeView.IsTextSelectionEnabled = true;
+ return nativeView;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.RichTextBlock {
+ return this.nativeViewProtected;
+ }
+
+ private _rebuildBlocks(): void {
+ const native = this.nativeViewProtected;
+ native.Blocks.Clear();
+ for (const p of buildParagraphs(this.html ?? '', this.linkColor)) {
+ native.Blocks.Append(p);
+ }
+ }
+
+ [htmlProperty.getDefault](): string {
+ return '';
+ }
+ [htmlProperty.setNative](_value: string) {
+ this._rebuildBlocks();
+ }
+
+ [selectableProperty.getDefault](): boolean {
+ return true;
+ }
+ [selectableProperty.setNative](value: boolean) {
+ this.nativeViewProtected.IsTextSelectionEnabled = value;
+ }
+
+ [colorProperty.getDefault](): Windows.UI.Xaml.Media.Brush {
+ return this.nativeViewProtected.Foreground;
+ }
+ [colorProperty.setNative](value: Color | Windows.UI.Xaml.Media.Brush) {
+ this.nativeViewProtected.Foreground = value instanceof Color
+ ? new Windows.UI.Xaml.Media.SolidColorBrush(value.windows)
+ : value;
+ }
+
+ [linkColorProperty.setNative](_value: Color) {
+ this._rebuildBlocks();
+ }
+
+ [fontInternalProperty.setNative](value: any) {
+ const native = this.nativeViewProtected as any;
+ value?.applyWindowsFont?.(native);
+ }
+}
diff --git a/packages/core/ui/image-cache/index.windows.ts b/packages/core/ui/image-cache/index.windows.ts
new file mode 100644
index 0000000000..211c19ad57
--- /dev/null
+++ b/packages/core/ui/image-cache/index.windows.ts
@@ -0,0 +1,60 @@
+export * from './image-cache-common';
+
+import * as common from './image-cache-common';
+import { request as httpRequest } from '../../http/http-request';
+import { Trace } from '../../trace';
+
+export class Cache extends common.Cache {
+ private _cache = new Map();
+
+ constructor() {
+ super();
+ }
+
+ public _downloadCore(request: common.DownloadRequest) {
+ httpRequest({ url: request.url, method: 'GET', responseType: 'arraybuffer' }).then(
+ (response) => {
+ try {
+ const raw = response.content?.raw;
+ const bytes = raw instanceof Uint8Array ? raw : raw instanceof ArrayBuffer ? new Uint8Array(raw) : null;
+ if (!bytes) {
+ this._onDownloadError(request.key, new Error('No data'));
+ return;
+ }
+
+ NSWinRT.toPromise(NativeScript.Widgets.ImageHelper.LoadFromBufferAsync(bytes as never)).then(
+ (bmp) => this._onDownloadCompleted(request.key, bmp),
+ (err) => this._onDownloadError(request.key, err)
+ );
+ } catch (err) {
+ this._onDownloadError(request.key, err);
+ }
+ },
+ (err) => {
+ this._onDownloadError(request.key, err);
+ }
+ );
+ }
+
+ public get(key: string): any {
+ return this._cache.get(key);
+ }
+
+ public set(key: string, image: any): void {
+ try {
+ if (key && image) {
+ this._cache.set(key, image);
+ }
+ } catch (err) {
+ Trace.write('Cache set error: ' + err, Trace.categories.Error, Trace.messageType.error);
+ }
+ }
+
+ public remove(key: string): void {
+ this._cache.delete(key);
+ }
+
+ public clear() {
+ this._cache.clear();
+ }
+}
diff --git a/packages/core/ui/image/index.windows.ts b/packages/core/ui/image/index.windows.ts
new file mode 100644
index 0000000000..eb58c6c988
--- /dev/null
+++ b/packages/core/ui/image/index.windows.ts
@@ -0,0 +1,149 @@
+export * from './image-common';
+
+import { ImageBase, stretchProperty, imageSourceProperty, srcProperty } from './image-common';
+import { ImageSource } from '../../image-source';
+import { ImageAsset } from '../../image-asset';
+import { Trace } from '../../trace';
+import { dispatchToMainThread, isMainThread } from '../../utils/mainthread-helper';
+
+const STRETCH_MAP: Record = {
+ none: 0, // Stretch.None
+ fill: 1, // Stretch.Fill
+ aspectFit: 2, // Stretch.Uniform
+ aspectFill: 3, // Stretch.UniformToFill
+};
+
+function bitmapFromBytesAsync(bytes: Uint8Array): Promise {
+ return new Promise((resolve, reject) => {
+ const createOnUIThread = (stream: any) => {
+ const create = () => {
+ try {
+ (stream as any).Seek(0);
+ const bmp = new (Windows as any).UI.Xaml.Media.Imaging.BitmapImage();
+ NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+ () => resolve(bmp),
+ (err: any) => reject(err)
+ );
+ } catch (e) {
+ reject(e);
+ }
+ };
+ if (isMainThread()) {
+ create();
+ } else {
+ dispatchToMainThread(create);
+ }
+ };
+
+ try {
+ const writer = new Windows.Storage.Streams.DataWriter();
+ writer.WriteBytes(bytes as never);
+ const buffer = writer.DetachBuffer();
+ const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+ NSWinRT.toPromise((stream as any).WriteAsync(buffer)).then(
+ () => createOnUIThread(stream),
+ (err: any) => reject(err)
+ );
+ } catch (e) {
+ reject(e);
+ }
+ });
+}
+
+export class Image extends ImageBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Image;
+ private _windows!: Windows.UI.Xaml.Controls.Image;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Image();
+ this.isLoading = false;
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.Image {
+ return this._windows;
+ }
+
+ public disposeImageSource() {
+ if (this.nativeViewProtected?.Source === this.imageSource?.windows) {
+ this.nativeViewProtected.Source = null as never;
+ }
+ if (this.imageSource?.windows) {
+ this.imageSource.windows = null;
+ }
+ this.imageSource = null as never;
+ }
+
+ [imageSourceProperty.setNative](value: ImageSource) {
+ if (value !== this.imageSource) {
+ this.disposeImageSource();
+ }
+ this._setNativeImage(value ? value.windows : null);
+ }
+
+ [srcProperty.setNative](value: string | ImageSource | ImageAsset) {
+ this._createImageSourceFromSrc(value);
+ }
+
+ //@ts-ignore
+ [stretchProperty.setNative](value: string) {
+ if (this.nativeViewProtected) {
+ this.nativeViewProtected.Stretch = STRETCH_MAP[value] ?? 2;
+ }
+ }
+
+ public _setNativeImage(nativeImage: any) {
+ if (!this.nativeViewProtected) {
+ if (Trace.isEnabled()) {
+ Trace.write('Image._setNativeImage: nativeViewProtected missing', Trace.categories.Error);
+ }
+ return;
+ }
+
+ if (this.nativeViewProtected.Source) {
+ this.nativeViewProtected.Source = null as never;
+ }
+
+ if (!nativeImage) {
+ if (Trace.isEnabled()) {
+ Trace.write('Image._setNativeImage: nativeImage is null/undefined', Trace.categories.Debug);
+ }
+ return;
+ }
+
+ if (nativeImage instanceof ArrayBuffer || nativeImage instanceof Uint8Array) {
+ const bytes = nativeImage instanceof Uint8Array ? nativeImage : new Uint8Array(nativeImage);
+ bitmapFromBytesAsync(bytes)
+ .then((bmp: any) => {
+ if (this.nativeViewProtected) {
+ this.nativeViewProtected.Source = bmp;
+ if (Trace.isEnabled()) {
+ Trace.write(`Image._setNativeImage: set Source to BitmapImage (PixelWidth=${bmp?.PixelWidth ?? 'unknown'})`, Trace.categories.Debug);
+ }
+ }
+ })
+ .catch((err) => {
+ if (Trace.isEnabled()) {
+ Trace.write(`Image._setNativeImage: bitmapFromBytesAsync error: ${err}`, Trace.categories.Error);
+ }
+ });
+ return;
+ }
+
+
+ try {
+ this.nativeViewProtected.Source = nativeImage;
+ if (Trace.isEnabled()) {
+ Trace.write(`Image._setNativeImage: set Source to nativeImage (type=${typeof nativeImage}, PixelWidth=${nativeImage?.PixelWidth ?? 'n/a'})`, Trace.categories.Debug);
+ }
+ } catch (err) {
+ if (Trace.isEnabled()) {
+ Trace.write(`Image._setNativeImage: error setting Source: ${err}`, Trace.categories.Error);
+ }
+ }
+ }
+}
diff --git a/packages/core/ui/image/symbol-effects.windows.ts b/packages/core/ui/image/symbol-effects.windows.ts
new file mode 100644
index 0000000000..bd02f2736c
--- /dev/null
+++ b/packages/core/ui/image/symbol-effects.windows.ts
@@ -0,0 +1,8 @@
+import { ImageSymbolEffectCommon } from './symbol-effects-common';
+export { ImageSymbolEffects } from './symbol-effects-common';
+
+export class ImageSymbolEffect extends ImageSymbolEffectCommon {
+ static fromSymbol(symbol: string) {
+ return new ImageSymbolEffect();
+ }
+}
diff --git a/packages/core/ui/label/index.windows.ts b/packages/core/ui/label/index.windows.ts
new file mode 100644
index 0000000000..972bf2e9be
--- /dev/null
+++ b/packages/core/ui/label/index.windows.ts
@@ -0,0 +1,66 @@
+import { TextBase, maxLinesProperty, textOverflowProperty } from '../text-base';
+import { CSSType } from '../core/view';
+import { booleanConverter } from '../core/view-base';
+
+@CSSType('Label')
+export class Label extends TextBase {
+ // nativeViewProtected is the Border wrapper — carries Background, CornerRadius, and border via CompositionBorderHandler.
+ nativeViewProtected: Windows.UI.Xaml.Controls.Border;
+ private _border: Windows.UI.Xaml.Controls.Border;
+ private _textBlock: Windows.UI.Xaml.Controls.TextBlock;
+
+ constructor() {
+ super();
+ this._textBlock = new Windows.UI.Xaml.Controls.TextBlock();
+ this._border = new Windows.UI.Xaml.Controls.Border();
+ (this._border as any).Child = this._textBlock;
+ }
+
+ public createNativeView(): Windows.UI.Xaml.Controls.Border {
+ return this._border;
+ }
+
+ // TextBase routes all text/font/color setNative handlers through nativeTextViewProtected.
+ get nativeTextViewProtected(): Windows.UI.Xaml.Controls.TextBlock {
+ return this._textBlock;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ // Center the TextBlock vertically within the Border so text appears centered.
+ try { (this._textBlock as any).VerticalAlignment = 1; } catch (_e) {}
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.TextBlock {
+ return this._textBlock;
+ }
+
+ get textWrap(): boolean {
+ return this.style.whiteSpace === 'normal';
+ }
+
+ set textWrap(value: boolean) {
+ if (typeof value === 'string') {
+ value = booleanConverter(value as any);
+ }
+ this.style.whiteSpace = value ? 'normal' : 'nowrap';
+ }
+
+ // MaxLines: 0 = unlimited
+ //@ts-ignore
+ [maxLinesProperty.setNative](value: number) {
+ try { (this._textBlock as any).MaxLines = value <= 0 ? 0 : value; } catch (_e) {}
+ }
+
+ // TextTrimming: None=0, CharacterEllipsis=1, WordEllipsis=2, Clip=3
+ //@ts-ignore
+ [textOverflowProperty.setNative](value: string) {
+ const nativeView = this._textBlock as any;
+ if (!nativeView) return;
+ switch (value) {
+ case 'ellipsis': nativeView.TextTrimming = 1; break; // CharacterEllipsis
+ case 'clip': nativeView.TextTrimming = 3; break;
+ default: nativeView.TextTrimming = 0; break; // None
+ }
+ }
+}
diff --git a/packages/core/ui/layouts/absolute-layout/index.windows.ts b/packages/core/ui/layouts/absolute-layout/index.windows.ts
new file mode 100644
index 0000000000..32281e201c
--- /dev/null
+++ b/packages/core/ui/layouts/absolute-layout/index.windows.ts
@@ -0,0 +1,44 @@
+export * from './absolute-layout-common';
+
+import { AbsoluteLayoutBase, leftProperty, topProperty } from './absolute-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+function setCanvasAttachedProperty(setterName: string, native: any, value: number) {
+ try {
+ const Canvas = Windows.UI.Xaml.Controls.Canvas as any;
+ if (Canvas && typeof Canvas[setterName] === 'function') {
+ // Canvas[setterName](native, value);
+ }
+ } catch (_e) {}
+}
+
+// Attach native setters on View so Canvas attached properties apply to native elements
+(View.prototype as any)[leftProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setCanvasAttachedProperty('SetLeft', native, value);
+ }
+};
+
+(View.prototype as any)[topProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setCanvasAttachedProperty('SetTop', native, value);
+ }
+};
+
+export class AbsoluteLayout extends AbsoluteLayoutBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Canvas;
+ private _windows: Windows.UI.Xaml.Controls.Canvas;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Canvas();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+}
diff --git a/packages/core/ui/layouts/dock-layout/index.windows.ts b/packages/core/ui/layouts/dock-layout/index.windows.ts
new file mode 100644
index 0000000000..e81b35c696
--- /dev/null
+++ b/packages/core/ui/layouts/dock-layout/index.windows.ts
@@ -0,0 +1,165 @@
+export * from './dock-layout-common';
+
+import { DockLayoutBase, dockProperty, stretchLastChildProperty } from './dock-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+export class DockLayout extends DockLayoutBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Canvas;
+ private _windows: Windows.UI.Xaml.Controls.Canvas;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Canvas();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ [stretchLastChildProperty.getDefault](): boolean {
+ return true;
+ }
+
+ [stretchLastChildProperty.setNative](value: boolean) {
+ // keep property in sync and request layout
+ this.stretchLastChild = value;
+ this.requestLayout();
+ }
+
+ public onDockChanged(view: View, oldValue: any, newValue: any) {
+ this.requestLayout();
+ }
+
+ public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+ let measureWidth = 0;
+ let measureHeight = 0;
+
+ const width = layout.getMeasureSpecSize(widthMeasureSpec);
+ const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+
+ const height = layout.getMeasureSpecSize(heightMeasureSpec);
+ const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+ const horizontalPaddingsAndMargins = this.effectivePaddingLeft + this.effectivePaddingRight + this.effectiveBorderLeftWidth + this.effectiveBorderRightWidth;
+ const verticalPaddingsAndMargins = this.effectivePaddingTop + this.effectivePaddingBottom + this.effectiveBorderTopWidth + this.effectiveBorderBottomWidth;
+
+ let remainingWidth = widthMode === layout.UNSPECIFIED ? Number.MAX_VALUE : width - horizontalPaddingsAndMargins;
+ let remainingHeight = heightMode === layout.UNSPECIFIED ? Number.MAX_VALUE : height - verticalPaddingsAndMargins;
+
+ let tempHeight = 0;
+ let tempWidth = 0;
+ let childWidthMeasureSpec: number;
+ let childHeightMeasureSpec: number;
+
+ this.eachLayoutChild((child, last) => {
+ if (this.stretchLastChild && last) {
+ childWidthMeasureSpec = layout.makeMeasureSpec(remainingWidth, widthMode);
+ childHeightMeasureSpec = layout.makeMeasureSpec(remainingHeight, heightMode);
+ } else {
+ childWidthMeasureSpec = layout.makeMeasureSpec(remainingWidth, widthMode === layout.EXACTLY ? layout.AT_MOST : widthMode);
+ childHeightMeasureSpec = layout.makeMeasureSpec(remainingHeight, heightMode === layout.EXACTLY ? layout.AT_MOST : heightMode);
+ }
+
+ const childSize = View.measureChild(this, child, childWidthMeasureSpec, childHeightMeasureSpec);
+
+ switch (child.dock) {
+ case 'top':
+ case 'bottom':
+ remainingHeight = Math.max(0, remainingHeight - childSize.measuredHeight);
+ tempHeight += childSize.measuredHeight;
+ measureWidth = Math.max(measureWidth, tempWidth + childSize.measuredWidth);
+ measureHeight = Math.max(measureHeight, tempHeight);
+ break;
+
+ case 'left':
+ case 'right':
+ default:
+ remainingWidth = Math.max(0, remainingWidth - childSize.measuredWidth);
+ tempWidth += childSize.measuredWidth;
+ measureWidth = Math.max(measureWidth, tempWidth);
+ measureHeight = Math.max(measureHeight, tempHeight + childSize.measuredHeight);
+ break;
+ }
+ });
+
+ measureWidth += horizontalPaddingsAndMargins;
+ measureHeight += verticalPaddingsAndMargins;
+
+ measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
+ measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
+
+ const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+ const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+
+ this.setMeasuredDimension(widthAndState, heightAndState);
+ }
+
+ public onLayout(left: number, top: number, right: number, bottom: number): void {
+ super.onLayout(left, top, right, bottom);
+
+ const insets = this.getSafeAreaInsets();
+ const horizontalPaddingsAndMargins = this.effectivePaddingLeft + this.effectivePaddingRight + this.effectiveBorderLeftWidth + this.effectiveBorderRightWidth + insets.left + insets.right;
+ const verticalPaddingsAndMargins = this.effectivePaddingTop + this.effectivePaddingBottom + this.effectiveBorderTopWidth + this.effectiveBorderBottomWidth + insets.top + insets.bottom;
+
+ let childLeft = this.effectiveBorderLeftWidth + this.effectivePaddingLeft + insets.left;
+ let childTop = this.effectiveBorderTopWidth + this.effectivePaddingTop + insets.top;
+
+ let x = childLeft;
+ let y = childTop;
+
+ let remainingWidth = Math.max(0, right - left - horizontalPaddingsAndMargins);
+ let remainingHeight = Math.max(0, bottom - top - verticalPaddingsAndMargins);
+
+ this.eachLayoutChild((child, last) => {
+ let childWidth = child.getMeasuredWidth() + child.effectiveMarginLeft + child.effectiveMarginRight;
+ let childHeight = child.getMeasuredHeight() + child.effectiveMarginTop + child.effectiveMarginBottom;
+
+ if (last && this.stretchLastChild) {
+ View.layoutChild(this, child, x, y, x + remainingWidth, y + remainingHeight);
+ return;
+ }
+
+ const dock = DockLayout.getDock(child);
+ let childLeftPos = 0;
+ let childTopPos = 0;
+
+ switch (dock) {
+ case 'top':
+ childLeftPos = x;
+ childTopPos = y;
+ childWidth = remainingWidth;
+ y += childHeight;
+ remainingHeight = Math.max(0, remainingHeight - childHeight);
+ break;
+
+ case 'bottom':
+ childLeftPos = x;
+ childTopPos = y + remainingHeight - childHeight;
+ childWidth = remainingWidth;
+ remainingHeight = Math.max(0, remainingHeight - childHeight);
+ break;
+
+ case 'right':
+ childLeftPos = x + remainingWidth - childWidth;
+ childTopPos = y;
+ childHeight = remainingHeight;
+ remainingWidth = Math.max(0, remainingWidth - childWidth);
+ break;
+
+ case 'left':
+ default:
+ childLeftPos = x;
+ childTopPos = y;
+ childHeight = remainingHeight;
+ x += childWidth;
+ remainingWidth = Math.max(0, remainingWidth - childWidth);
+ break;
+ }
+
+ View.layoutChild(this, child, childLeftPos, childTopPos, childLeftPos + childWidth, childTopPos + childHeight);
+ });
+ }
+}
diff --git a/packages/core/ui/layouts/flexbox-layout/index.windows.ts b/packages/core/ui/layouts/flexbox-layout/index.windows.ts
new file mode 100644
index 0000000000..750b3cae16
--- /dev/null
+++ b/packages/core/ui/layouts/flexbox-layout/index.windows.ts
@@ -0,0 +1,347 @@
+export * from './flexbox-layout-common';
+
+import {
+ FlexboxLayoutBase,
+ FlexDirection, FlexWrap, JustifyContent, AlignItems, AlignContent, AlignSelf,
+ flexDirectionProperty, flexWrapProperty, justifyContentProperty,
+ alignItemsProperty, alignContentProperty,
+ orderProperty, Order,
+ flexGrowProperty, FlexGrow,
+ flexShrinkProperty, FlexShrink,
+ flexWrapBeforeProperty, FlexWrapBefore,
+ alignSelfProperty,
+} from './flexbox-layout-common';
+import { View } from '../../core/view';
+
+const alignSelfMap: Record = {
+ [AlignSelf.AUTO]: -1,
+ [AlignSelf.FLEX_START]: 0,
+ [AlignSelf.FLEX_END]: 1,
+ [AlignSelf.CENTER]: 2,
+ [AlignSelf.BASELINE]: 3,
+ [AlignSelf.STRETCH]: 4,
+};
+
+(View.prototype as any)[orderProperty.setNative] = function (value: Order) {
+ try { (this as any).__ns_order = value; } catch (_e) { }
+};
+(View.prototype as any)[flexGrowProperty.setNative] = function (value: FlexGrow) {
+ try { (this as any).__ns_flexGrow = value; } catch (_e) { }
+};
+(View.prototype as any)[flexShrinkProperty.setNative] = function (value: FlexShrink) {
+ try { (this as any).__ns_flexShrink = value; } catch (_e) { }
+};
+(View.prototype as any)[flexWrapBeforeProperty.setNative] = function (value: FlexWrapBefore) {
+ try { (this as any).__ns_wrapBefore = value; } catch (_e) { }
+};
+(View.prototype as any)[alignSelfProperty.setNative] = function (value: AlignSelf) {
+ try { (this as any).__ns_alignSelf = alignSelfMap[value]; } catch (_e) { }
+};
+
+export class FlexboxLayout extends FlexboxLayoutBase {
+ nativeViewProtected!: Windows.UI.Xaml.Controls.Canvas;
+ private _canvas!: Windows.UI.Xaml.Controls.Canvas;
+ private _layoutBusy = false;
+ // Tracks the canvas height we set ourselves so we can distinguish it from user-set heights.
+ private _ownHeight = NaN;
+
+ constructor() {
+ super();
+ this._canvas = new Windows.UI.Xaml.Controls.Canvas();
+ }
+
+ createNativeView(): Windows.UI.Xaml.Controls.Canvas {
+ return this._canvas;
+ }
+
+ initNativeView(): void {
+ super.initNativeView(); // keeps LayoutUpdated = _onSizeChanged (background, clip, etc.)
+ const canvas = this.nativeViewProtected as any;
+ const ref = new WeakRef(this);
+ // SizeChanged fires during XAML's layout pass (before render). Using the typed
+ // SizeChangedEventHandler constructor avoids the delegate-type mismatch crash.
+ try {
+ canvas.SizeChanged = new (Windows.UI.Xaml as any).SizeChangedEventHandler((_sender: any, _args: any) => {
+ const owner = ref.deref();
+ if (!owner) return;
+ owner._runFlexLayout();
+ });
+ } catch (_e) {
+ // Fallback: override LayoutUpdated (fires after layout, same convergence with one extra pass).
+ canvas.LayoutUpdated = () => {
+ const owner = ref.deref();
+ if (!owner) return;
+ try { (owner as any)._onSizeChanged(); } catch (_e2) { }
+ owner._runFlexLayout();
+ };
+ }
+ }
+
+ disposeNativeView(): void {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView) {
+ try { nativeView.SizeChanged = null; } catch (_e) { }
+ try { nativeView.LayoutUpdated = null; } catch (_e) { }
+ }
+ super.disposeNativeView();
+ }
+
+ public _addViewToNativeVisualTree(child: View, atIndex?: number): boolean {
+ const res = super._addViewToNativeVisualTree(child, atIndex);
+ if (res) this._runFlexLayout();
+ return res;
+ }
+
+ public _removeViewFromNativeVisualTree(child: View): void {
+ super._removeViewFromNativeVisualTree(child);
+ this._runFlexLayout();
+ }
+
+ private _runFlexLayout(): void {
+ if (this._layoutBusy) return;
+ const canvas = this.nativeViewProtected as any;
+ if (!canvas) return;
+ const w = canvas.ActualWidth as number;
+ const h = canvas.ActualHeight as number;
+ if (!w) return;
+
+ this._layoutBusy = true;
+ try {
+ const contentH = this._doFlexLayout(w, h, canvas);
+ // Canvas doesn't self-size. If parent gave us 0 height (auto-height context like
+ // StackLayout), set canvas.Height to the computed content height so the parent
+ // re-measures and allocates the correct space.
+ const canvasH = canvas.Height as number;
+ const inAutoMode = isNaN(canvasH) || (!isNaN(this._ownHeight) && Math.abs(canvasH - this._ownHeight) < 0.5);
+ if (inAutoMode && contentH > 0 && Math.abs(h - contentH) > 0.5) {
+ this._ownHeight = contentH;
+ canvas.Height = contentH;
+ }
+ } finally {
+ this._layoutBusy = false;
+ }
+ }
+
+ // Returns total content height (for row direction) or width (column direction).
+ private _doFlexLayout(availW: number, availH: number, canvas: any): number {
+ const children = canvas.Children;
+ const count: number = children?.Size ?? 0;
+ if (count === 0) return 0;
+
+ const flexDir = this.flexDirection ?? FlexDirection.ROW;
+ const flexWrapVal = this.flexWrap ?? FlexWrap.NOWRAP;
+ const isRow = flexDir === FlexDirection.ROW || flexDir === FlexDirection.ROW_REVERSE;
+ const doWrap = flexWrapVal !== FlexWrap.NOWRAP;
+ const mainAv = isRow ? availW : availH;
+ const crossAv = isRow ? availH : availW;
+ // Treat 0 as unconstrained: Canvas in auto-height StackLayout has ActualHeight=0.
+ const mainInf = !Number.isFinite(mainAv) || mainAv === 0;
+ const crossInf = !Number.isFinite(crossAv) || crossAv === 0;
+
+ const items: any[] = [];
+ let origIdx = 0;
+ for (let i = 0; i < count; i++) {
+ const nc = children.GetAt(i);
+ try { if (nc.Visibility === Windows.UI.Xaml.Visibility.Collapsed) continue; } catch (_e) { }
+ items.push({
+ nc,
+ origIdx: origIdx++,
+ flexGrow: Number((nc as any).__ns_flexGrow ?? 0),
+ flexShrink: Number((nc as any).__ns_flexShrink ?? 1),
+ flexBasisPercent: Number((nc as any).__ns_flexBasisPercent ?? -1),
+ alignSelf: Number((nc as any).__ns_alignSelf ?? -1),
+ wrapBefore: !!((nc as any).__ns_wrapBefore),
+ mainSize: 0,
+ crossSize: 0,
+ });
+ }
+
+ items.sort((a, b) => {
+ const ao = Number((a.nc as any).__ns_order ?? 1);
+ const bo = Number((b.nc as any).__ns_order ?? 1);
+ return ao !== bo ? ao - bo : a.origIdx - b.origIdx;
+ });
+
+ for (const item of items) {
+ this._measureItem(item, mainAv, crossAv, mainInf, crossInf, isRow);
+ }
+
+ const lines: any[] = [];
+ let cur: any = { items: [], mainSize: 0, crossSize: 0 };
+ for (const item of items) {
+ const forceBreak = doWrap && item.wrapBefore && cur.items.length > 0;
+ const overflow = doWrap && !mainInf && cur.items.length > 0 && cur.mainSize + item.mainSize > mainAv + 0.001;
+ if (forceBreak || overflow) { lines.push(cur); cur = { items: [], mainSize: 0, crossSize: 0 }; }
+ cur.items.push(item);
+ cur.mainSize += item.mainSize;
+ if (item.crossSize > cur.crossSize) cur.crossSize = item.crossSize;
+ }
+ if (cur.items.length > 0) lines.push(cur);
+
+ if (!mainInf) {
+ for (const line of lines) {
+ const free = mainAv - line.mainSize;
+ if (free > 0.001) this._applyGrow(line, free, crossAv, crossInf, isRow);
+ else if (free < -0.001) this._applyShrink(line, free, crossAv, crossInf, isRow);
+ }
+ }
+
+ const lineCount = lines.length;
+ const totalCross = lines.reduce((s, l) => s + l.crossSize, 0);
+ const effectiveCross = crossInf ? totalCross : crossAv;
+ const freeCross = effectiveCross - totalCross;
+ const alignCont = this.alignContent ?? AlignContent.STRETCH;
+ const stretchExtra = alignCont === AlignContent.STRETCH && freeCross > 0 && lineCount > 0 ? freeCross / lineCount : 0;
+ const revWrap = flexWrapVal === FlexWrap.WRAP_REVERSE;
+ const revMain = flexDir === FlexDirection.ROW_REVERSE || flexDir === FlexDirection.COLUMN_REVERSE;
+ const mainFn = mainInf ? lines.reduce((m, l) => Math.max(m, l.mainSize), 0) : mainAv;
+ const justify = this.justifyContent ?? JustifyContent.FLEX_START;
+ const alignItemsVal = this.alignItems ?? AlignItems.STRETCH;
+
+ const lineStarts: number[] = new Array(lineCount).fill(0);
+ const lineSizes: number[] = new Array(lineCount).fill(0);
+ {
+ let p = 0, g = 0;
+ switch (alignCont) {
+ case AlignContent.FLEX_END: p = freeCross; break;
+ case AlignContent.CENTER: p = freeCross / 2; break;
+ case AlignContent.SPACE_BETWEEN: g = lineCount > 1 ? freeCross / (lineCount - 1) : 0; break;
+ case AlignContent.SPACE_AROUND: g = lineCount > 0 ? freeCross / lineCount : 0; p = g / 2; break;
+ }
+ for (let vi = 0; vi < lineCount; vi++) {
+ const li = revWrap ? (lineCount - 1 - vi) : vi;
+ const sz = lines[li].crossSize + stretchExtra;
+ lineStarts[vi] = p; lineSizes[vi] = sz; p += sz + g;
+ }
+ }
+
+ for (let vi = 0; vi < lineCount; vi++) {
+ const li = revWrap ? (lineCount - 1 - vi) : vi;
+ const line = lines[li];
+ const crossStart = lineStarts[vi];
+ const lineCross = lineSizes[vi];
+ const n = line.items.length;
+
+ const mainPos: number[] = new Array(n).fill(0);
+ {
+ const free = mainFn - line.mainSize;
+ let mc = 0, mg = 0;
+ switch (justify) {
+ case JustifyContent.FLEX_END: mc = free; break;
+ case JustifyContent.CENTER: mc = free / 2; break;
+ case JustifyContent.SPACE_BETWEEN: mg = n > 1 ? free / (n - 1) : 0; break;
+ case JustifyContent.SPACE_AROUND: mg = n > 0 ? free / n : 0; mc = mg / 2; break;
+ }
+ for (let vj = 0; vj < n; vj++) {
+ const lj = revMain ? (n - 1 - vj) : vj;
+ mainPos[vj] = mc; mc += line.items[lj].mainSize + mg;
+ }
+ }
+
+ for (let vj = 0; vj < n; vj++) {
+ const lj = revMain ? (n - 1 - vj) : vj;
+ const item = line.items[lj];
+
+ let alignStr = alignItemsVal;
+ if (item.alignSelf !== -1) {
+ switch (item.alignSelf) {
+ case 0: alignStr = AlignItems.FLEX_START; break;
+ case 1: alignStr = AlignItems.FLEX_END; break;
+ case 2: alignStr = AlignItems.CENTER; break;
+ case 3: alignStr = AlignItems.BASELINE; break;
+ case 4: alignStr = AlignItems.STRETCH; break;
+ }
+ }
+
+ let itemCross = item.crossSize;
+ let crossPos = crossStart;
+ if (alignStr === AlignItems.STRETCH) {
+ itemCross = lineCross;
+ } else if (alignStr === AlignItems.FLEX_END) {
+ crossPos = crossStart + lineCross - item.crossSize;
+ } else if (alignStr === AlignItems.CENTER) {
+ crossPos = crossStart + (lineCross - item.crossSize) / 2;
+ }
+
+ const ms = mainPos[vj];
+ try {
+ Windows.UI.Xaml.Controls.Canvas.SetLeft(item.nc, isRow ? ms : crossPos);
+ Windows.UI.Xaml.Controls.Canvas.SetTop(item.nc, isRow ? crossPos : ms);
+ item.nc.Width = isRow ? item.mainSize : itemCross;
+ item.nc.Height = isRow ? itemCross : item.mainSize;
+ } catch (_e) { }
+ }
+ }
+
+ return isRow ? totalCross : mainFn;
+ }
+
+ private _measureItem(item: any, mainAv: number, crossAv: number, mainInf: boolean, crossInf: boolean, isRow: boolean): void {
+ const basisMain = (!mainInf && item.flexBasisPercent >= 0) ? mainAv * item.flexBasisPercent / 100 : NaN;
+ const mainW = Number.isNaN(basisMain) ? (mainInf ? Infinity : mainAv) : basisMain;
+ const crossW = crossInf ? Infinity : crossAv;
+ try {
+ item.nc.Measure(Windows.UI.Xaml.SizeHelper.FromDimensions(isRow ? mainW : crossW, isRow ? crossW : mainW));
+ const d = item.nc.DesiredSize;
+ item.mainSize = Number.isNaN(basisMain) ? (isRow ? d.Width : d.Height) : basisMain;
+ item.crossSize = isRow ? d.Height : d.Width;
+ } catch (_e) {
+ item.mainSize = Number.isNaN(basisMain) ? 0 : basisMain;
+ item.crossSize = 0;
+ }
+ }
+
+ private _remeasure(item: any, crossAv: number, crossInf: boolean, isRow: boolean): void {
+ const crossW = crossInf ? Infinity : crossAv;
+ try {
+ item.nc.Measure(Windows.UI.Xaml.SizeHelper.FromDimensions(isRow ? item.mainSize : crossW, isRow ? crossW : item.mainSize));
+ const d = item.nc.DesiredSize;
+ item.crossSize = isRow ? d.Height : d.Width;
+ } catch (_e) { item.crossSize = 0; }
+ }
+
+ private _applyGrow(line: any, free: number, crossAv: number, crossInf: boolean, isRow: boolean): void {
+ let totalGrow = 0;
+ for (const it of line.items) totalGrow += it.flexGrow;
+ if (totalGrow <= 0) return;
+ const perUnit = free / totalGrow;
+ let maxCross = 0;
+ for (const it of line.items) {
+ if (it.flexGrow > 0) { it.mainSize += it.flexGrow * perUnit; this._remeasure(it, crossAv, crossInf, isRow); }
+ if (it.crossSize > maxCross) maxCross = it.crossSize;
+ }
+ line.crossSize = maxCross;
+ line.mainSize += free;
+ }
+
+ private _applyShrink(line: any, free: number, crossAv: number, crossInf: boolean, isRow: boolean): void {
+ let totalShrink = 0;
+ for (const it of line.items) totalShrink += it.flexShrink * it.mainSize;
+ if (totalShrink <= 0) return;
+ let maxCross = 0;
+ for (const it of line.items) {
+ if (it.flexShrink > 0) {
+ const ratio = (it.flexShrink * it.mainSize) / totalShrink;
+ it.mainSize = Math.max(0, it.mainSize + free * ratio);
+ this._remeasure(it, crossAv, crossInf, isRow);
+ }
+ if (it.crossSize > maxCross) maxCross = it.crossSize;
+ }
+ line.crossSize = maxCross;
+ }
+
+ [flexDirectionProperty.getDefault](): FlexDirection { return flexDirectionProperty.defaultValue; }
+ [flexDirectionProperty.setNative](_v: FlexDirection) { }
+
+ [flexWrapProperty.getDefault](): FlexWrap { return flexWrapProperty.defaultValue; }
+ [flexWrapProperty.setNative](_v: FlexWrap) { }
+
+ [justifyContentProperty.getDefault](): JustifyContent { return justifyContentProperty.defaultValue; }
+ [justifyContentProperty.setNative](_v: JustifyContent) { }
+
+ [alignItemsProperty.getDefault](): AlignItems { return alignItemsProperty.defaultValue; }
+ [alignItemsProperty.setNative](_v: AlignItems) { }
+
+ [alignContentProperty.getDefault](): AlignContent { return alignContentProperty.defaultValue; }
+ [alignContentProperty.setNative](_v: AlignContent) { }
+}
diff --git a/packages/core/ui/layouts/grid-layout/index.windows.ts b/packages/core/ui/layouts/grid-layout/index.windows.ts
new file mode 100644
index 0000000000..1e2faf5fbb
--- /dev/null
+++ b/packages/core/ui/layouts/grid-layout/index.windows.ts
@@ -0,0 +1,181 @@
+export * from './grid-layout-common';
+
+import { GridLayoutBase, ItemSpec as ItemSpecBase, rowProperty, columnProperty, rowSpanProperty, columnSpanProperty, GridUnitType } from './grid-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+function setGridAttachedProperty(setterName: string, native: any, value: number) {
+ try {
+ const Grid = Windows.UI.Xaml.Controls.Grid as any;
+ if (Grid && typeof Grid[setterName] === 'function') {
+ Grid[setterName](native, value);
+ }
+ } catch (_e) {}
+}
+
+// Attach native setters on View so Grid layout attached properties apply to native elements
+(View.prototype as any)[rowProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setGridAttachedProperty('SetRow', native, value);
+ }
+};
+
+(View.prototype as any)[columnProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setGridAttachedProperty('SetColumn', native, value);
+ }
+};
+
+(View.prototype as any)[rowSpanProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setGridAttachedProperty('SetRowSpan', native, value);
+ }
+};
+
+(View.prototype as any)[columnSpanProperty.setNative] = function (value: number) {
+ const native = (this as any).nativeViewProtected as any;
+ if (native) {
+ setGridAttachedProperty('SetColumnSpan', native, value);
+ }
+};
+
+export class GridLayout extends GridLayoutBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Grid;
+ private _windows: Windows.UI.Xaml.Controls.Grid;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Grid();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView && super.initNativeView();
+ this._updateRowAndColumnDefinitions();
+ }
+
+ public resetNativeView(): void {
+ try {
+ if (this._windows) {
+ try { this._windows.RowDefinitions.Clear(); } catch (_e) {}
+ try { this._windows.ColumnDefinitions.Clear(); } catch (_e) {}
+ }
+ } catch (_e) {}
+ super.resetNativeView && super.resetNativeView();
+ }
+
+ private _createRowDefinition(itemSpec: ItemSpecBase) {
+ try {
+ const rd = new Windows.UI.Xaml.Controls.RowDefinition();
+ try {
+ if (itemSpec.gridUnitType === GridUnitType.AUTO) {
+ rd.Height = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.auto);
+ } else if (itemSpec.gridUnitType === GridUnitType.STAR) {
+ rd.Height = new Windows.UI.Xaml.GridLength(itemSpec.value, Windows.UI.Xaml.GridUnitType.star);
+ } else {
+ // pixel
+ rd.Height = new Windows.UI.Xaml.GridLength(layout.toDeviceIndependentPixels(itemSpec.value), Windows.UI.Xaml.GridUnitType.pixel);
+ }
+ } catch (_e) {}
+ return rd;
+ } catch (_e) {
+ return null;
+ }
+ }
+
+ private _createColumnDefinition(itemSpec: ItemSpecBase) {
+ try {
+ const cd = new Windows.UI.Xaml.Controls.ColumnDefinition();
+ try {
+ if (itemSpec.gridUnitType === GridUnitType.AUTO) {
+ cd.Width = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.auto);
+ } else if (itemSpec.gridUnitType === GridUnitType.STAR) {
+ cd.Width = new Windows.UI.Xaml.GridLength(itemSpec.value, Windows.UI.Xaml.GridUnitType.star);
+ } else {
+ // pixel
+ cd.Width = new Windows.UI.Xaml.GridLength(layout.toDeviceIndependentPixels(itemSpec.value), Windows.UI.Xaml.GridUnitType.pixel);
+ }
+ } catch (_e) {}
+ return cd;
+ } catch (_e) {
+ return null;
+ }
+ }
+
+ private _updateRowAndColumnDefinitions(): void {
+ const native = this._windows as any;
+ if (!native) return;
+
+ try {
+ // Build row defs
+ const rowDefs = [] as any[];
+ for (let i = 0; i < this.rowsInternal.length; i++) {
+ const item = this.rowsInternal[i];
+ const rd = this._createRowDefinition(item);
+ if (rd) rowDefs.push(rd);
+ }
+ try { native.RowDefinitions.ReplaceAll(rowDefs); } catch (_e) {
+ // fallback: append
+ try { native.RowDefinitions.Clear(); } catch (_e2) {}
+ for (const rd of rowDefs) {
+ try { native.RowDefinitions.Append(rd); } catch (_e3) {}
+ }
+ }
+ } catch (_e) {}
+
+ try {
+ // Build column defs
+ const colDefs = [] as any[];
+ for (let i = 0; i < this.columnsInternal.length; i++) {
+ const item = this.columnsInternal[i];
+ const cd = this._createColumnDefinition(item);
+ if (cd) colDefs.push(cd);
+ }
+ try { native.ColumnDefinitions.ReplaceAll(colDefs); } catch (_e) {
+ try { native.ColumnDefinitions.Clear(); } catch (_e2) {}
+ for (const cd of colDefs) {
+ try { native.ColumnDefinitions.Append(cd); } catch (_e3) {}
+ }
+ }
+ } catch (_e) {}
+ }
+
+ public _onRowAdded(itemSpec: ItemSpecBase) {
+ this._updateRowAndColumnDefinitions();
+ }
+
+ public _onColumnAdded(itemSpec: ItemSpecBase) {
+ this._updateRowAndColumnDefinitions();
+ }
+
+ public _onRowRemoved(itemSpec: ItemSpecBase, index: number) {
+ this._updateRowAndColumnDefinitions();
+ }
+
+ public _onColumnRemoved(itemSpec: ItemSpecBase, index: number) {
+ this._updateRowAndColumnDefinitions();
+ }
+
+ public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+ const res = super._addViewToNativeVisualTree(child, atIndex);
+
+ try {
+ const nativeChild = (child as any).nativeViewProtected as any;
+ if (res && nativeChild && this._windows) {
+ const Grid = Windows.UI.Xaml.Controls.Grid as any;
+ try { Grid.SetRow(nativeChild, GridLayout.getRow(child)); } catch (_e) {}
+ try { Grid.SetColumn(nativeChild, GridLayout.getColumn(child)); } catch (_e) {}
+ try { Grid.SetRowSpan(nativeChild, GridLayout.getRowSpan(child)); } catch (_e) {}
+ try { Grid.SetColumnSpan(nativeChild, GridLayout.getColumnSpan(child)); } catch (_e) {}
+ }
+ } catch (_e) {}
+
+ return res;
+ }
+}
diff --git a/packages/core/ui/layouts/layout-base.windows.ts b/packages/core/ui/layouts/layout-base.windows.ts
new file mode 100644
index 0000000000..16ff18c7d2
--- /dev/null
+++ b/packages/core/ui/layouts/layout-base.windows.ts
@@ -0,0 +1,5 @@
+import { LayoutBaseCommon } from './layout-base-common';
+
+export * from './layout-base-common';
+
+export class LayoutBase extends LayoutBaseCommon {}
diff --git a/packages/core/ui/layouts/liquid-glass-container/index.windows.ts b/packages/core/ui/layouts/liquid-glass-container/index.windows.ts
new file mode 100644
index 0000000000..66dc25d279
--- /dev/null
+++ b/packages/core/ui/layouts/liquid-glass-container/index.windows.ts
@@ -0,0 +1,5 @@
+export * from './liquid-glass-container-common';
+
+import { LiquidGlassContainerCommon } from './liquid-glass-container-common';
+
+export class LiquidGlassContainer extends LiquidGlassContainerCommon {}
diff --git a/packages/core/ui/layouts/liquid-glass/index.windows.ts b/packages/core/ui/layouts/liquid-glass/index.windows.ts
new file mode 100644
index 0000000000..bdb74c3651
--- /dev/null
+++ b/packages/core/ui/layouts/liquid-glass/index.windows.ts
@@ -0,0 +1,5 @@
+export * from './liquid-glass-common';
+
+import { LiquidGlassCommon } from './liquid-glass-common';
+
+export class LiquidGlass extends LiquidGlassCommon {}
diff --git a/packages/core/ui/layouts/root-layout/index.windows.ts b/packages/core/ui/layouts/root-layout/index.windows.ts
new file mode 100644
index 0000000000..028dbf85dd
--- /dev/null
+++ b/packages/core/ui/layouts/root-layout/index.windows.ts
@@ -0,0 +1,129 @@
+export * from './root-layout-common';
+
+import { Color } from '../../../color';
+import { View } from '../../core/view';
+import { RootLayoutBase, defaultShadeCoverOptions } from './root-layout-common';
+import { TransitionAnimation, ShadeCoverOptions } from '.';
+import { parseLinearGradient } from '../../../css/parser';
+import { LinearGradient } from '../../styling/linear-gradient';
+import { layout } from '../../../utils';
+
+export class RootLayout extends RootLayoutBase {
+ insertChild(view: View, atIndex: number): boolean {
+ return super.insertChild(view, atIndex);
+ }
+
+ removeChild(view: View): void {
+ super.removeChild(view);
+ }
+
+ protected _bringToFront(view: View) {
+ try {
+ const native = view.nativeViewProtected as any;
+ const parentNative = this.nativeViewProtected as any;
+ if (!native || !parentNative || !parentNative.Children) {
+ return;
+ }
+
+ let maxZ = Number.MIN_SAFE_INTEGER;
+ const children = parentNative.Children;
+ for (let i = 0; i < children.Size; i++) {
+ try {
+ const child = children.GetAt(i);
+ const z = Windows.UI.Xaml.Controls.Panel.GetZIndex(child) || 0;
+ if (z > maxZ) maxZ = z;
+ } catch (_e) {
+ // ignore
+ }
+ }
+
+ const newZ = (maxZ === Number.MIN_SAFE_INTEGER) ? 0 : (maxZ + 1);
+ try {
+ Windows.UI.Xaml.Controls.Panel.SetZIndex(native, newZ);
+ } catch (_e) { }
+ } catch (_e) { }
+ }
+
+ protected _initShadeCover(view: View, shadeOptions: ShadeCoverOptions): void {
+ const options: TransitionAnimation = {
+ ...defaultShadeCoverOptions.animation.enterFrom,
+ ...(shadeOptions && shadeOptions.animation && shadeOptions.animation.enterFrom ? shadeOptions.animation.enterFrom : {}),
+ } as TransitionAnimation;
+
+ try {
+ const native = view.nativeViewProtected as any;
+ if (!native) return;
+
+ // Set initial platform native values
+ try { native.Opacity = options.opacity; } catch (_e) { }
+
+ try {
+ const ct = new Windows.UI.Xaml.Media.CompositeTransform();
+ ct.TranslateX = layout.toDeviceIndependentPixels(options.translateX);
+ ct.TranslateY = layout.toDeviceIndependentPixels(options.translateY);
+ ct.ScaleX = options.scaleX;
+ ct.ScaleY = options.scaleY;
+ ct.Rotation = options.rotate;
+ native.RenderTransform = ct;
+ native.RenderTransformOrigin = Windows.UI.Xaml.PointHelper.FromCoordinates(0.5, 0.5);
+ } catch (_e) { }
+ } catch (_e) { }
+ }
+
+ protected _updateShadeCover(view: View, shadeOptions: ShadeCoverOptions = {}): Promise {
+ const options = {
+ ...defaultShadeCoverOptions,
+ ...(shadeOptions || {}),
+ } as ShadeCoverOptions;
+
+ // Determine if background is a gradient string
+ const isBackgroundGradient = typeof options.color === 'string' && options.color.indexOf('linear-gradient') === 0;
+
+ if (isBackgroundGradient) {
+ // prefer backgroundImage for gradients
+ try {
+ if (view.backgroundColor) {
+ view.backgroundColor = undefined;
+ }
+ const parsed = parseLinearGradient(options.color as string);
+ view.backgroundImage = LinearGradient.parse(parsed.value);
+ } catch (_e) {
+ // fail silently
+ }
+ } else {
+ try {
+ if (view.backgroundImage) {
+ view.backgroundImage = undefined;
+ }
+ if (options.color) {
+ view.backgroundColor = (options.color instanceof Color) ? (options.color as Color) : new Color(options.color as any);
+ }
+ } catch (_e) { }
+ }
+
+ // Animate shade cover to default state (enter animation)
+ const enterFrom = options.animation && options.animation.enterFrom ? options.animation.enterFrom : defaultShadeCoverOptions.animation.enterFrom;
+ return this.getEnterAnimation(view as View, enterFrom).play();
+ }
+
+ protected _closeShadeCover(view: View, shadeOptions: ShadeCoverOptions = {}): Promise {
+ const exitState: TransitionAnimation = {
+ ...defaultShadeCoverOptions.animation.exitTo,
+ ...(shadeOptions && shadeOptions.animation && shadeOptions.animation.exitTo ? shadeOptions.animation.exitTo : {}),
+ } as TransitionAnimation;
+ return this.getExitAnimation(view as View, exitState).play();
+ }
+
+ protected _cleanupPlatformShadeCover(): void {
+ try {
+ if (!this._shadeCover) return;
+ const native = (this._shadeCover as any).nativeViewProtected as any;
+ if (native) {
+ try { native.RenderTransform = null; } catch (_e) { }
+ try { native.Opacity = 1; } catch (_e) { }
+ }
+ try { this._shadeCover.backgroundImage = undefined; } catch (_e) { }
+ try { this._shadeCover.backgroundColor = undefined as any; } catch (_e) { }
+ } catch (_e) { }
+ }
+}
diff --git a/packages/core/ui/layouts/stack-layout/index.windows.ts b/packages/core/ui/layouts/stack-layout/index.windows.ts
new file mode 100644
index 0000000000..6aea3f8796
--- /dev/null
+++ b/packages/core/ui/layouts/stack-layout/index.windows.ts
@@ -0,0 +1,66 @@
+export * from './stack-layout-common';
+
+import { StackLayoutBase, orientationProperty } from './stack-layout-common';
+import type { ViewCommon } from '../../core/view/view-common';
+
+export class StackLayout extends StackLayoutBase {
+ // nativeViewProtected is the Border wrapper — it carries Padding and stretches to fill its parent.
+ nativeViewProtected!: Windows.UI.Xaml.Controls.Border;
+ private _border!: Windows.UI.Xaml.Controls.Border;
+ private _panel!: Windows.UI.Xaml.Controls.StackPanel;
+
+ constructor() {
+ super();
+ this._border = new Windows.UI.Xaml.Controls.Border();
+ this._panel = new Windows.UI.Xaml.Controls.StackPanel();
+ this._panel.Orientation = Windows.UI.Xaml.Controls.Orientation.Vertical;
+ (this._border as any).Child = this._panel;
+ }
+
+ public createNativeView(): Windows.UI.Xaml.Controls.Border {
+ return this._border;
+ }
+
+ // Children go into the inner StackPanel, not the Border.
+ public _addViewToNativeVisualTree(child: ViewCommon, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+ super._addViewToNativeVisualTree(child, atIndex);
+ const nativeChild = (child as any).nativeViewProtected as any;
+ if (!nativeChild) return false;
+ const children = (this._panel as any).Children;
+ if (!children) return false;
+ try {
+ const size: number = children.Size;
+ if (atIndex >= 0 && atIndex < size && atIndex < Number.MAX_SAFE_INTEGER) {
+ children.InsertAt(atIndex, nativeChild);
+ } else {
+ children.Append(nativeChild);
+ }
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+ const nativeChild = (child as any).nativeViewProtected as any;
+ if (nativeChild) {
+ const children = (this._panel as any).Children;
+ const count: number = children?.Size ?? 0;
+ for (let i = 0; i < count; i++) {
+ try {
+ if (children.GetAt(i) === nativeChild) {
+ children.RemoveAt(i);
+ break;
+ }
+ } catch (_e) {}
+ }
+ }
+ super._removeViewFromNativeVisualTree(child);
+ }
+
+ [orientationProperty.setNative](value: 'horizontal' | 'vertical') {
+ this._panel.Orientation = value === 'vertical'
+ ? Windows.UI.Xaml.Controls.Orientation.Vertical
+ : Windows.UI.Xaml.Controls.Orientation.Horizontal;
+ }
+}
diff --git a/packages/core/ui/layouts/wrap-layout/index.windows.ts b/packages/core/ui/layouts/wrap-layout/index.windows.ts
new file mode 100644
index 0000000000..0386be1f6b
--- /dev/null
+++ b/packages/core/ui/layouts/wrap-layout/index.windows.ts
@@ -0,0 +1,182 @@
+export * from './wrap-layout-common';
+
+import { WrapLayoutBase } from './wrap-layout-common';
+
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+export class WrapLayout extends WrapLayoutBase {
+ private _lengths: Array = new Array();
+
+ private static getChildMeasureSpec(parentMode: number, parentLength: number, itemLength): number {
+ if (itemLength > 0) {
+ return layout.makeMeasureSpec(itemLength, layout.EXACTLY);
+ } else if (parentMode === layout.UNSPECIFIED) {
+ return layout.makeMeasureSpec(0, layout.UNSPECIFIED);
+ } else {
+ return layout.makeMeasureSpec(parentLength, layout.AT_MOST);
+ }
+ }
+
+ public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+ let measureWidth = 0;
+ let measureHeight = 0;
+
+ const width = layout.getMeasureSpecSize(widthMeasureSpec);
+ const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+
+ const height = layout.getMeasureSpecSize(heightMeasureSpec);
+ const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+ const horizontalPaddingsAndMargins = this.effectivePaddingLeft + this.effectivePaddingRight + this.effectiveBorderLeftWidth + this.effectiveBorderRightWidth;
+ const verticalPaddingsAndMargins = this.effectivePaddingTop + this.effectivePaddingBottom + this.effectiveBorderTopWidth + this.effectiveBorderBottomWidth;
+
+ const availableWidth = widthMode === layout.UNSPECIFIED ? Number.MAX_VALUE : width - horizontalPaddingsAndMargins;
+ const availableHeight = heightMode === layout.UNSPECIFIED ? Number.MAX_VALUE : height - verticalPaddingsAndMargins;
+
+ const childWidthMeasureSpec: number = WrapLayout.getChildMeasureSpec(widthMode, availableWidth, this.effectiveItemWidth);
+ const childHeightMeasureSpec: number = WrapLayout.getChildMeasureSpec(heightMode, availableHeight, this.effectiveItemHeight);
+
+ let remainingWidth = availableWidth;
+ let remainingHeight = availableHeight;
+
+ this._lengths.length = 0;
+ let rowOrColumn = 0;
+ let maxLength = 0;
+
+ const isVertical = this.orientation === 'vertical';
+
+ const useItemWidth: boolean = this.effectiveItemWidth > 0;
+ const useItemHeight: boolean = this.effectiveItemHeight > 0;
+ const itemWidth = this.effectiveItemWidth;
+ const itemHeight = this.effectiveItemHeight;
+
+ this.eachLayoutChild((child, last) => {
+ const desiredSize = View.measureChild(this, child, childWidthMeasureSpec, childHeightMeasureSpec);
+ const childMeasuredWidth = useItemWidth ? itemWidth : desiredSize.measuredWidth;
+ const childMeasuredHeight = useItemHeight ? itemHeight : desiredSize.measuredHeight;
+ const isFirst = this._lengths.length <= rowOrColumn;
+
+ if (isVertical) {
+ if (childMeasuredHeight > remainingHeight) {
+ rowOrColumn++;
+ maxLength = Math.max(maxLength, measureHeight);
+ measureHeight = childMeasuredHeight;
+ remainingHeight = availableHeight - childMeasuredHeight;
+ this._lengths[isFirst ? rowOrColumn - 1 : rowOrColumn] = childMeasuredWidth;
+ } else {
+ remainingHeight -= childMeasuredHeight;
+ measureHeight += childMeasuredHeight;
+ }
+ } else {
+ if (childMeasuredWidth > remainingWidth) {
+ rowOrColumn++;
+ maxLength = Math.max(maxLength, measureWidth);
+ measureWidth = childMeasuredWidth;
+ remainingWidth = availableWidth - childMeasuredWidth;
+ this._lengths[isFirst ? rowOrColumn - 1 : rowOrColumn] = childMeasuredHeight;
+ } else {
+ remainingWidth -= childMeasuredWidth;
+ measureWidth += childMeasuredWidth;
+ }
+ }
+
+ if (isFirst) {
+ this._lengths[rowOrColumn] = isVertical ? childMeasuredWidth : childMeasuredHeight;
+ } else {
+ this._lengths[rowOrColumn] = Math.max(this._lengths[rowOrColumn], isVertical ? childMeasuredWidth : childMeasuredHeight);
+ }
+ });
+
+ if (isVertical) {
+ measureHeight = Math.max(maxLength, measureHeight);
+ this._lengths.forEach((value, index, array) => {
+ measureWidth += value;
+ });
+ } else {
+ measureWidth = Math.max(maxLength, measureWidth);
+ this._lengths.forEach((value, index, array) => {
+ measureHeight += value;
+ });
+ }
+
+ measureWidth += horizontalPaddingsAndMargins;
+ measureHeight += verticalPaddingsAndMargins;
+
+ // Check against our minimum sizes
+ measureWidth = Math.max(measureWidth, this.effectiveMinWidth);
+ measureHeight = Math.max(measureHeight, this.effectiveMinHeight);
+
+ const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+ const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+
+ this.setMeasuredDimension(widthAndState, heightAndState);
+ }
+
+ public onLayout(left: number, top: number, right: number, bottom: number): void {
+ super.onLayout(left, top, right, bottom);
+
+ const insets = this.getSafeAreaInsets();
+ const isVertical = this.orientation === 'vertical';
+ const paddingLeft = this.effectiveBorderLeftWidth + this.effectivePaddingLeft + insets.left;
+ const paddingTop = this.effectiveBorderTopWidth + this.effectivePaddingTop + insets.top;
+ const paddingRight = this.effectiveBorderRightWidth + this.effectivePaddingRight + insets.right;
+ const paddingBottom = this.effectiveBorderBottomWidth + this.effectivePaddingBottom + insets.bottom;
+
+ let childLeft = paddingLeft;
+ let childTop = paddingTop;
+ const childrenHeight = bottom - top - paddingBottom;
+ const childrenWidth = right - left - paddingRight;
+ let rowOrColumn = 0;
+
+ this.eachLayoutChild((child, last) => {
+ let childHeight = child.getMeasuredHeight() + child.effectiveMarginTop + child.effectiveMarginBottom;
+ let childWidth = child.getMeasuredWidth() + child.effectiveMarginLeft + child.effectiveMarginRight;
+
+ const length = this._lengths[rowOrColumn];
+ if (isVertical) {
+ childWidth = length;
+ childHeight = this.effectiveItemHeight > 0 ? this.effectiveItemHeight : childHeight;
+ const isFirst = childTop === paddingTop;
+ if (childTop + childHeight > childrenHeight && childLeft + childWidth <= childrenWidth) {
+ childTop = paddingTop;
+
+ if (!isFirst) {
+ childLeft += length;
+ }
+
+ rowOrColumn++;
+ childWidth = this._lengths[isFirst ? rowOrColumn - 1 : rowOrColumn];
+ }
+
+ if (childLeft < childrenWidth && childTop < childrenHeight) {
+ View.layoutChild(this, child, childLeft, childTop, childLeft + childWidth, childTop + childHeight);
+ }
+
+ childTop += childHeight;
+ } else {
+ childWidth = this.effectiveItemWidth > 0 ? this.effectiveItemWidth : childWidth;
+ childHeight = length;
+ const isFirst = childLeft === paddingLeft;
+ if (childLeft + childWidth > childrenWidth && childTop + childHeight <= childrenHeight) {
+ childLeft = paddingLeft;
+
+ if (!isFirst) {
+ childTop += length;
+ }
+
+ rowOrColumn++;
+ childHeight = this._lengths[isFirst ? rowOrColumn - 1 : rowOrColumn];
+ }
+
+ if (childLeft < childrenWidth && childTop < childrenHeight) {
+ View.layoutChild(this, child, childLeft, childTop, childLeft + childWidth, childTop + childHeight);
+ }
+
+ childLeft += childWidth;
+ }
+ });
+ }
+}
diff --git a/packages/core/ui/list-picker/index.windows.ts b/packages/core/ui/list-picker/index.windows.ts
new file mode 100644
index 0000000000..5e5c7e8348
--- /dev/null
+++ b/packages/core/ui/list-picker/index.windows.ts
@@ -0,0 +1,125 @@
+export * from './list-picker-common';
+
+import { ListPickerBase, selectedIndexProperty, itemsProperty, ItemsSource } from './list-picker-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+
+export class ListPicker extends ListPickerBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.ComboBox;
+ private _windows: Windows.UI.Xaml.Controls.ComboBox;
+ private _selectionHandler: any = null;
+ private _selectionHandlerUsedAddListener: boolean = false;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.ComboBox();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.ComboBox {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ const that = new WeakRef(this);
+ let usedAdd = false;
+ try {
+ this._selectionHandler = new Windows.UI.Xaml.Controls.SelectionChangedEventHandler((s, e) => {
+ const owner = that.deref();
+ if (!owner) {
+ return;
+ }
+ const native = owner.nativeViewProtected as any;
+ const idx = native.SelectedIndex;
+ selectedIndexProperty.nativeValueChange(owner, idx);
+ owner.updateSelectedValue(idx);
+ });
+ this.nativeViewProtected.SelectionChanged = this._selectionHandler as never;
+ } catch (_e) {
+ this._selectionHandler = (s: any, e: any) => {
+ const owner = that.deref();
+ if (!owner) return;
+ const native = owner.nativeViewProtected as any;
+ const idx = native.SelectedIndex;
+ selectedIndexProperty.nativeValueChange(owner, idx);
+ owner.updateSelectedValue(idx);
+ };
+ try {
+ this.nativeViewProtected.SelectionChanged = this._selectionHandler as never;
+ } catch (_e2) {
+ try {
+ if (typeof (this.nativeViewProtected as any).addEventListener === 'function') {
+ (this.nativeViewProtected as any).addEventListener('selectionchanged', this._selectionHandler);
+ usedAdd = true;
+ }
+ } catch (_e3) {}
+ }
+ }
+ this._selectionHandlerUsedAddListener = usedAdd;
+ }
+
+ public disposeNativeView(): void {
+ if (this._selectionHandler) {
+ try { this.nativeViewProtected.SelectionChanged = null as never; } catch (_e) {}
+ if (this._selectionHandlerUsedAddListener) {
+ try { (this.nativeViewProtected as any).removeEventListener('selectionchanged', this._selectionHandler); } catch (_e) {}
+ }
+ this._selectionHandler = null;
+ this._selectionHandlerUsedAddListener = false;
+ }
+ super.disposeNativeView();
+ }
+
+ [selectedIndexProperty.getDefault](): number {
+ return -1;
+ }
+ [selectedIndexProperty.setNative](value: number) {
+ if (value >= 0 && this.nativeViewProtected) {
+ this.nativeViewProtected.SelectedIndex = value;
+ }
+ }
+
+ [itemsProperty.getDefault](): any[] {
+ return null;
+ }
+ [itemsProperty.setNative](value: any[] | ItemsSource) {
+ const native = this.nativeViewProtected;
+ if (!native) return;
+
+ try {
+ native.Items.Clear();
+ if (value && Array.isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ const dataItem = this._getDataItem(i);
+ native.Items.Append(dataItem != null ? (dataItem.toString ? dataItem.toString() : String(dataItem)) : '');
+ }
+ }
+ } catch (_e) {
+ // best-effort
+ }
+
+ // Coerce selected index after updating items.
+ selectedIndexProperty.coerce(this);
+ }
+
+ [colorProperty.getDefault](): any {
+ try {
+ return (this.nativeViewProtected.Foreground as any)?.Color;
+ } catch (_e) {
+ return null;
+ }
+ }
+ [colorProperty.setNative](value: Color | any) {
+ try {
+ const brush = new Windows.UI.Xaml.Media.SolidColorBrush(value instanceof Color ? value.windows : value);
+ this.nativeViewProtected.Foreground = brush as never;
+ } catch (_e) {
+ // ignore
+ }
+ }
+}
+
diff --git a/packages/core/ui/list-view/index.windows.ts b/packages/core/ui/list-view/index.windows.ts
new file mode 100644
index 0000000000..56ec913340
--- /dev/null
+++ b/packages/core/ui/list-view/index.windows.ts
@@ -0,0 +1,247 @@
+export * from './list-view-common';
+
+import { ListViewBase, itemTemplatesProperty, rowHeightProperty, separatorColorProperty } from './list-view-common';
+import { KeyedTemplate, View } from '../core/view';
+import { ChangedData } from '../../data/observable-array';
+import { Color } from '../../color';
+import { layout } from '../../utils';
+
+const ITEMLOADING = ListViewBase.itemLoadingEvent;
+const ITEMTAP = ListViewBase.itemTapEvent;
+const LOADMOREITEMS = ListViewBase.loadMoreItemsEvent;
+
+export class ListView extends ListViewBase {
+ nativeViewProtected!: Windows.UI.Xaml.Controls.ListView;
+
+ private _itemClickDelegate: any = null;
+ // All NS views in tree, keyed by item index
+ private _views = new Map();
+ // All native views in ItemsSource, in order
+ private _nativeItems: any[] = [];
+
+ public createNativeView(): Windows.UI.Xaml.Controls.ListView {
+ const lv = new Windows.UI.Xaml.Controls.ListView();
+ (lv as any).IsItemClickEnabled = true;
+ (lv as any).SelectionMode = 0; // None
+ (lv as any).HorizontalAlignment = 3; // Stretch
+ (lv as any).HorizontalContentAlignment = 3; // Stretch
+ (lv as any).VerticalAlignment = 3; // Stretch
+ return lv;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ const lv = this.nativeViewProtected;
+ if (!lv) return;
+ const ref = new WeakRef(this);
+
+ this._itemClickDelegate = new (Windows.UI.Xaml.Controls as any).ItemClickEventHandler((_sender: any, e: any) => {
+ const owner = ref.deref();
+ if (!owner) return;
+ try {
+ const clicked = e?.ClickedItem;
+ if (clicked == null) return;
+ const index: number = (clicked as any).__ns_index ?? -1;
+ if (index < 0) return;
+ const view = owner._views.get(index) ?? null;
+ const section = (clicked as any).__ns_section;
+ // Include section when available (sectioned lists)
+ owner.notify({ eventName: ITEMTAP, object: owner, index, view, section });
+ } catch (_e) {}
+ });
+ try { (lv as any).ItemClick = this._itemClickDelegate; } catch (_e) {}
+ }
+
+ public disposeNativeView(): void {
+ try { (this.nativeViewProtected as any).ItemClick = null; } catch (_e) {}
+ this._itemClickDelegate = null;
+ this._destroyAllViews();
+ super.disposeNativeView?.();
+ }
+
+ // Views are managed manually — skip the default native visual tree placement.
+ public _addViewToNativeVisualTree(child: View, atIndex?: number): boolean {
+ if (this._views.has((child as any).__ns_index ?? -2)) return true;
+ return super._addViewToNativeVisualTree(child, atIndex);
+ }
+
+ private _destroyAllViews(): void {
+ for (const view of this._views.values()) {
+ try { this._removeView(view); } catch (_e) {}
+ }
+ this._views.clear();
+ this._nativeItems = [];
+ }
+
+ private _getItemCount(): number {
+ if (!this.items) return 0;
+ if (!this.sectioned) {
+ const src = this.items as any;
+ return typeof src.length === 'number' ? src.length : 0;
+ }
+
+ // Sectioned: sum lengths of all sections
+ let total = 0;
+ const sections = this._getSectionCount();
+ for (let s = 0; s < sections; s++) {
+ const itemsInSection = this._getItemsInSection(s) as any;
+ if (!itemsInSection) continue;
+ if (typeof itemsInSection.length === 'number') {
+ total += itemsInSection.length;
+ }
+ }
+ return total;
+ }
+
+ public refresh(): void {
+ const lv = this.nativeViewProtected;
+ if (!lv) return;
+
+ this._destroyAllViews();
+
+ const count = this._getItemCount();
+ const nativeItems: any[] = [];
+
+ if (this.sectioned) {
+ let globalIndex = 0;
+ const sections = this._getSectionCount();
+ for (let s = 0; s < sections; s++) {
+ const itemsInSection = this._getItemsInSection(s) as any;
+ const sectionLen = itemsInSection && typeof itemsInSection.length === 'number' ? itemsInSection.length : 0;
+ for (let j = 0; j < sectionLen; j++) {
+ try {
+ // Determine data item for template selection
+ const dataItem = this._getDataItemInSection(s, j);
+ let templateKey = 'default';
+ try {
+ if ((this as any)._itemTemplateSelector) {
+ templateKey = (this as any)._itemTemplateSelector(dataItem, globalIndex, this.items);
+ }
+ } catch (_e) {}
+ let template = this._itemTemplatesInternal[0];
+ for (let t of this._itemTemplatesInternal) {
+ if (t.key === templateKey) { template = t; break; }
+ }
+
+ // Create the view first
+ let view: View | null = null as any;
+ try { view = template.createView(); } catch (_e) {}
+ if (!view) view = this._getDefaultItemContent(globalIndex);
+ if (!view) { globalIndex++; continue; }
+
+ (view as any).__ns_index = globalIndex;
+ // Prepare (set bindingContext) before firing itemLoading so handlers see data-bound context
+ this._prepareItemInSection(view, s, j);
+
+ const args: any = { eventName: ITEMLOADING, object: this, index: globalIndex, view: view, section: s };
+ this.notify(args);
+ // If handler replaced the view, ensure it is prepared and indexed
+ view = args.view || view;
+ if (!(view as any).__ns_index) (view as any).__ns_index = globalIndex;
+ this._prepareItemInSection(view, s, j);
+ this._views.set(globalIndex, view as View);
+ this._addView(view as View);
+
+ const nativeContent = (view as any).nativeViewProtected;
+ if (nativeContent) {
+ (nativeContent as any).__ns_index = globalIndex;
+ (nativeContent as any).__ns_section = s;
+ (nativeContent as any).__ns_indexInSection = j;
+ nativeItems.push(nativeContent);
+ }
+ globalIndex++;
+ } catch (_e) {}
+ }
+ }
+ } else {
+ for (let i = 0; i < count; i++) {
+ try {
+ const template = this._getItemTemplate(i);
+ // Create and prepare view before notifying so bindingContext is available in handlers
+ let view: View | null = null as any;
+ try { view = template.createView(); } catch (_e) {}
+ if (!view) view = this._getDefaultItemContent(i);
+ if (!view) continue;
+
+ (view as any).__ns_index = i;
+ this._prepareItem(view, i);
+ const args: any = { eventName: ITEMLOADING, object: this, index: i, view: view };
+ this.notify(args);
+ view = args.view || view;
+ if (!(view as any).__ns_index) (view as any).__ns_index = i;
+ this._prepareItem(view, i);
+ try { console.log('[ListView.win] prepared item', i, 'bindingContext=', (view as any).bindingContext ? 'object' : typeof (view as any).bindingContext, 'hasNative=', !!(view as any).nativeViewProtected); } catch (_e) {}
+ this._views.set(i, view as View);
+ this._addView(view as View);
+
+ const nativeContent = (view as any).nativeViewProtected;
+ if (nativeContent) {
+ (nativeContent as any).__ns_index = i;
+ nativeItems.push(nativeContent);
+ }
+ } catch (_e) {}
+ }
+ }
+
+ this._nativeItems = nativeItems;
+ try { (lv as any).ItemsSource = nativeItems; } catch (_e) {}
+
+ if (count > 0) {
+ this.notify({ eventName: LOADMOREITEMS, object: this });
+ }
+ }
+
+ public eachChildView(callback: (child: View) => boolean): void {
+ for (const view of this._views.values()) {
+ if (!callback(view)) break;
+ }
+ }
+
+ public isItemAtIndexVisible(index: number): boolean {
+ try { return !!this.nativeViewProtected?.ContainerFromIndex(index); } catch (_e) { return false; }
+ }
+
+ public scrollToIndex(index: number): void {
+ const item = this._nativeItems[index];
+ if (!item) return;
+ try { this.nativeViewProtected?.ScrollIntoView(item); } catch (_e) {}
+ }
+
+ public scrollToIndexAnimated(index: number): void {
+ this.scrollToIndex(index);
+ }
+
+ public onLoaded(): void {
+ super.onLoaded();
+ this.refresh();
+ }
+
+ public _onItemsChanged(_data: ChangedData): void {
+ this.refresh();
+ }
+
+ [itemTemplatesProperty.getDefault](): KeyedTemplate[] {
+ return null as unknown as KeyedTemplate[];
+ }
+ [itemTemplatesProperty.setNative](value: KeyedTemplate[]) {
+ this._itemTemplatesInternal = new Array(this._defaultTemplate);
+ if (value) {
+ this._itemTemplatesInternal = this._itemTemplatesInternal.concat(value);
+ }
+ if (this.nativeViewProtected) this.refresh();
+ }
+
+ [rowHeightProperty.getDefault]() {
+ return 'auto' as any;
+ }
+ [rowHeightProperty.setNative](_value: any) {
+ // Applied per-item via _effectiveRowHeight in refresh().
+ }
+
+ [separatorColorProperty.getDefault](): Color {
+ return null as unknown as Color;
+ }
+ [separatorColorProperty.setNative](_value: Color) {
+ // WinUI ListView separators are style-based; not directly settable.
+ }
+}
diff --git a/packages/core/ui/page/index.windows.ts b/packages/core/ui/page/index.windows.ts
new file mode 100644
index 0000000000..fb8de8cef4
--- /dev/null
+++ b/packages/core/ui/page/index.windows.ts
@@ -0,0 +1,59 @@
+export * from './page-common';
+
+import { PageBase } from './page-common';
+import type { View } from '../core/view';
+
+export class Page extends PageBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.Grid;
+ private _grid: Windows.UI.Xaml.Controls.Grid;
+
+ constructor() {
+ super();
+ this._grid = new Windows.UI.Xaml.Controls.Grid();
+ }
+
+ public createNativeView() {
+ return this._grid;
+ }
+
+ public disposeNativeView(): void {
+ this._grid = null;
+ super.disposeNativeView();
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.Grid {
+ return this._grid;
+ }
+
+ public _addViewToNativeVisualTree(child: View, _atIndex: number): boolean {
+ if (this.actionBar && child === (this.actionBar as any)) {
+ return true;
+ }
+
+ const nativeGrid = this._grid;
+ const nativeChild = (child as any).nativeViewProtected as any;
+
+ if (nativeGrid && nativeChild) {
+ (nativeGrid as any).Children.Append(nativeChild);
+ return true;
+ }
+
+ return false;
+ }
+
+ public _removeViewFromNativeVisualTree(child: View): void {
+ if (this.actionBar && child === (this.actionBar as any)) {
+ return;
+ }
+
+ if (this._grid) {
+ const children = (this._grid as any).Children;
+ const count = children?.Size ?? 0;
+ for (let i = count - 1; i >= 0; i--) {
+ try { children.RemoveAt(i); } catch (_e) {}
+ }
+ }
+
+ super._removeViewFromNativeVisualTree(child);
+ }
+}
diff --git a/packages/core/ui/progress/index.windows.ts b/packages/core/ui/progress/index.windows.ts
new file mode 100644
index 0000000000..f88bee773d
--- /dev/null
+++ b/packages/core/ui/progress/index.windows.ts
@@ -0,0 +1,81 @@
+import { maxValueProperty, ProgressBase, valueProperty } from './progress-common';
+import { Color } from '../../color';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+
+export * from './progress-common';
+
+export class Progress extends ProgressBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.ProgressBar;
+ private _windows: Windows.UI.Xaml.Controls.ProgressBar;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.ProgressBar();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+
+ [valueProperty.getDefault](): number {
+ return 0;
+ }
+ [valueProperty.setNative](value: number) {
+ this.nativeViewProtected.Value = value;
+ }
+
+ [maxValueProperty.getDefault](): number {
+ return 100;
+ }
+ [maxValueProperty.setNative](value: number) {
+ this.nativeViewProtected.Maximum = value;
+ }
+
+ [colorProperty.getDefault](): android.graphics.drawable.Drawable {
+ return null;
+ }
+ [colorProperty.setNative](value: Color) {
+ const color = value instanceof Color ? value.windows : value
+ if (color) {
+ if (typeof color === 'number') {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(
+ new Color(color).windows
+ );
+ } else {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(
+ color
+ );
+ }
+ } else {
+ this.nativeViewProtected.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush();
+ }
+ }
+
+ [backgroundColorProperty.getDefault](): number {
+ return null;
+ }
+ [backgroundColorProperty.setNative](value: Color) {
+ const color = value instanceof Color ? value.windows : value
+ if (color) {
+ if (typeof color === 'number') {
+ this.nativeViewProtected.Background = new Windows.UI.Xaml.Media.SolidColorBrush(
+ new Color(color).windows
+ );
+ } else {
+ this.nativeViewProtected.Background = new Windows.UI.Xaml.Media.SolidColorBrush(
+ color
+ );
+ }
+ } else {
+ this.nativeViewProtected.Background = new Windows.UI.Xaml.Media.SolidColorBrush();
+ }
+ }
+
+ [backgroundInternalProperty.getDefault](): number {
+ return null;
+ }
+ [backgroundInternalProperty.setNative](value: Color) {
+ //
+ }
+}
diff --git a/packages/core/ui/scroll-view/index.windows.ts b/packages/core/ui/scroll-view/index.windows.ts
new file mode 100644
index 0000000000..38dd873548
--- /dev/null
+++ b/packages/core/ui/scroll-view/index.windows.ts
@@ -0,0 +1,257 @@
+export * from './scroll-view-common';
+
+import { ScrollViewBase, isScrollEnabledProperty, scrollBarIndicatorVisibleProperty } from './scroll-view-common';
+import type { ScrollEventData } from '.';
+import type { ViewCommon } from '../core/view/view-common';
+
+export class ScrollView extends ScrollViewBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.ScrollViewer;
+
+ private _scrollToken: any = null;
+ private _windows: Windows.UI.Xaml.Controls.ScrollViewer;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.ScrollViewer();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ this._applyOrientation();
+ }
+
+ public disposeNativeView(): void {
+ this._scrollToken = null;
+ super.disposeNativeView();
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.ScrollViewer {
+ return this._windows;
+ }
+
+ private _applyOrientation(): void {
+ const viewer = this.windows as any;
+ if (!viewer) {
+ return;
+ }
+
+ const HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment;
+ const VerticalAlignment = Windows.UI.Xaml.VerticalAlignment;
+ const ScrollBarVisibility = Windows.UI.Xaml.Controls.ScrollBarVisibility;
+ const ScrollMode = Windows.UI.Xaml.Controls.ScrollMode;
+
+ if (this.orientation === 'horizontal') {
+ viewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
+ viewer.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
+
+ viewer.HorizontalScrollMode = ScrollMode.Enabled;
+ viewer.VerticalScrollMode = ScrollMode.Disabled;
+
+ viewer.HorizontalContentAlignment = HorizontalAlignment.Left;
+ viewer.VerticalContentAlignment = VerticalAlignment.Stretch;
+ } else {
+ viewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
+ viewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
+
+ viewer.VerticalScrollMode = ScrollMode.Enabled;
+ viewer.HorizontalScrollMode = ScrollMode.Disabled;
+
+
+ viewer.VerticalContentAlignment = VerticalAlignment.Top;
+ viewer.HorizontalContentAlignment = HorizontalAlignment.Stretch;
+ }
+ }
+
+ public _onOrientationChanged(): void {
+ this._applyOrientation();
+ }
+
+ public _addViewToNativeVisualTree(child: ViewCommon, _atIndex: number): boolean {
+ super._addViewToNativeVisualTree(child);
+
+ const nativeParent = this.nativeViewProtected as any;
+ const nativeChild = (child as any).nativeViewProtected as any;
+
+ if (nativeParent && nativeChild) {
+ const HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment;
+ const VerticalAlignment = Windows.UI.Xaml.VerticalAlignment;
+
+
+ if (this.orientation === 'horizontal') {
+ nativeChild.HorizontalAlignment = HorizontalAlignment.Left;
+ nativeChild.VerticalAlignment = VerticalAlignment.Stretch;
+ } else {
+ nativeChild.VerticalAlignment = VerticalAlignment.Top;
+ nativeChild.HorizontalAlignment = HorizontalAlignment.Stretch;
+ }
+
+ nativeParent.Content = nativeChild;
+
+ // Force remeasure/layout so extent updates correctly.
+ try {
+ nativeChild.InvalidateMeasure();
+ nativeChild.UpdateLayout();
+ } catch (_e) {}
+
+ try {
+ nativeParent.InvalidateMeasure();
+ nativeParent.UpdateLayout();
+ } catch (_e) {}
+
+ return true;
+ }
+
+ return false;
+ }
+
+ public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+ if (this.nativeViewProtected) {
+ (this.nativeViewProtected as any).Content = null;
+ }
+
+ super._removeViewFromNativeVisualTree(child);
+ }
+
+ protected attachNative(): void {
+ const viewer = this.windows;
+
+ if (!viewer) {
+ return;
+ }
+
+ const that = new WeakRef(this);
+
+ this._scrollToken = NSWinRT.asDelegate((_sender: any, _args: any) => {
+ const owner = that.deref();
+
+ if (!owner) {
+ return;
+ }
+
+ owner.notify({
+ eventName: ScrollViewBase.scrollEvent,
+ object: owner,
+ scrollX: owner.horizontalOffset,
+ scrollY: owner.verticalOffset,
+ });
+ });
+
+ viewer.ViewChanged = this._scrollToken;
+ }
+
+ protected detachNative(): void {
+ const viewer = this.windows;
+
+ if (!viewer) {
+ return;
+ }
+
+ viewer.ViewChanged = null as never;
+ this._scrollToken = null;
+ }
+
+ get horizontalOffset(): number {
+ return this.nativeViewProtected ? this.nativeViewProtected.HorizontalOffset : 0;
+ }
+
+ get verticalOffset(): number {
+ return this.nativeViewProtected ? this.nativeViewProtected.VerticalOffset : 0;
+ }
+
+ get scrollableWidth(): number {
+ if (!this.nativeViewProtected || this.orientation !== 'horizontal') {
+ return 0;
+ }
+
+ return Math.max(
+ 0,
+ this.nativeViewProtected.ExtentWidth - this.nativeViewProtected.ViewportWidth
+ );
+ }
+
+ get scrollableHeight(): number {
+ if (!this.nativeViewProtected || this.orientation !== 'vertical') {
+ return 0;
+ }
+
+ return Math.max(
+ 0,
+ this.nativeViewProtected.ExtentHeight - this.nativeViewProtected.ViewportHeight
+ );
+ }
+
+ public scrollToVerticalOffset(value: number, animated: boolean) {
+ if (
+ this.nativeViewProtected &&
+ this.orientation === 'vertical' &&
+ this.isScrollEnabled
+ ) {
+ this.nativeViewProtected.ChangeView(
+ null as never,
+ value as never,
+ null as never,
+ !animated
+ );
+ }
+ }
+
+ public scrollToHorizontalOffset(value: number, animated: boolean) {
+ if (
+ this.nativeViewProtected &&
+ this.orientation === 'horizontal' &&
+ this.isScrollEnabled
+ ) {
+ this.nativeViewProtected.ChangeView(
+ value as never,
+ null as never,
+ null as never,
+ !animated
+ );
+ }
+ }
+
+ [isScrollEnabledProperty.setNative](value: boolean): void {
+ const viewer = this.nativeViewProtected as any;
+
+ if (!viewer) {
+ return;
+ }
+
+ const ScrollMode = Windows.UI.Xaml.Controls.ScrollMode;
+
+ if (this.orientation === 'horizontal') {
+ viewer.HorizontalScrollMode = value
+ ? ScrollMode.Enabled
+ : ScrollMode.Disabled;
+ } else {
+ viewer.VerticalScrollMode = value
+ ? ScrollMode.Enabled
+ : ScrollMode.Disabled;
+ }
+ }
+
+ [scrollBarIndicatorVisibleProperty.setNative](value: boolean): void {
+ const viewer = this.nativeViewProtected as any;
+
+ if (!viewer) {
+ return;
+ }
+
+ const ScrollBarVisibility =
+ Windows.UI.Xaml.Controls.ScrollBarVisibility;
+
+ if (this.orientation === 'horizontal') {
+ viewer.HorizontalScrollBarVisibility = value
+ ? ScrollBarVisibility.Auto
+ : ScrollBarVisibility.Hidden;
+ } else {
+ viewer.VerticalScrollBarVisibility = value
+ ? ScrollBarVisibility.Auto
+ : ScrollBarVisibility.Hidden;
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/core/ui/search-bar/index.windows.ts b/packages/core/ui/search-bar/index.windows.ts
new file mode 100644
index 0000000000..a271453107
--- /dev/null
+++ b/packages/core/ui/search-bar/index.windows.ts
@@ -0,0 +1,153 @@
+export * from './search-bar-common';
+
+import { SearchBarBase, textProperty, hintProperty, textFieldBackgroundColorProperty, textFieldHintColorProperty, clearButtonColorProperty } from './search-bar-common';
+import { Color } from '../../color';
+
+export class SearchBar extends SearchBarBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.AutoSuggestBox;
+ private _textHandler: any;
+ private _textHandlerUsedAddListener: boolean = false;
+ private _queryHandler: any;
+ private _queryHandlerUsedAddListener: boolean = false;
+ private _windows: Windows.UI.Xaml.Controls.AutoSuggestBox;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.AutoSuggestBox();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.AutoSuggestBox {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+ const that = new WeakRef(this);
+ const native = this.nativeViewProtected;
+
+ let textUsedAdd = false;
+ let queryUsedAdd = false;
+ try {
+ this._textHandler = new Windows.Foundation.TypedEventHandler((s, e) => {
+ const owner = that.deref();
+ if (!owner) return;
+ textProperty.nativeValueChange(owner, native.Text || '');
+ });
+ native.TextChanged = this._textHandler as never;
+
+ this._queryHandler = new Windows.Foundation.TypedEventHandler((s, e) => {
+ const owner = that.deref();
+ if (!owner) return;
+ owner.notify({ eventName: SearchBarBase.submitEvent, object: owner });
+ });
+ native.QuerySubmitted = this._queryHandler as never;
+ } catch (_e) {
+ // Fallback: use plain functions and attempt property assign or addEventListener
+ this._textHandler = (s: any, e: any) => {
+ const owner = that.deref();
+ if (!owner) return;
+ textProperty.nativeValueChange(owner, native.Text || '');
+ };
+ try {
+ native.TextChanged = this._textHandler as never;
+ } catch (_e2) {
+ try {
+ if (typeof (native as any).addEventListener === 'function') {
+ (native as any).addEventListener('textchanged', this._textHandler);
+ textUsedAdd = true;
+ }
+ } catch (_e3) {}
+ }
+
+ this._queryHandler = (s: any, e: any) => {
+ const owner = that.deref();
+ if (!owner) return;
+ owner.notify({ eventName: SearchBarBase.submitEvent, object: owner });
+ };
+ try {
+ native.QuerySubmitted = this._queryHandler as never;
+ } catch (_e2) {
+ try {
+ if (typeof (native as any).addEventListener === 'function') {
+ (native as any).addEventListener('querysubmitted', this._queryHandler);
+ queryUsedAdd = true;
+ }
+ } catch (_e3) {}
+ }
+
+ this._textHandlerUsedAddListener = textUsedAdd;
+ this._queryHandlerUsedAddListener = queryUsedAdd;
+ }
+ }
+
+ public disposeNativeView(): void {
+ try {
+ if (this._textHandler) {
+ try { this.nativeViewProtected.TextChanged = null as never; } catch (_e) {}
+ if (this._textHandlerUsedAddListener) {
+ try { (this.nativeViewProtected as any).removeEventListener('textchanged', this._textHandler); } catch (_e) {}
+ }
+ this._textHandler = null;
+ }
+ if (this._queryHandler) {
+ try { this.nativeViewProtected.QuerySubmitted = null as never; } catch (_e) {}
+ if (this._queryHandlerUsedAddListener) {
+ try { (this.nativeViewProtected as any).removeEventListener('querysubmitted', this._queryHandler); } catch (_e) {}
+ }
+ this._queryHandler = null;
+ }
+ } catch (_e) {}
+
+ super.disposeNativeView();
+ }
+
+ public dismissSoftInput() {
+ // No-op for UWP; clearing focus if possible
+ try {
+ if (this.nativeViewProtected) {
+ (this.nativeViewProtected as any).IsEnabled = false;
+ (this.nativeViewProtected as any).IsEnabled = true;
+ }
+ } catch (_e) {}
+ }
+
+ [textProperty.setNative](value: string) {
+ const native = this.nativeViewProtected;
+ if (!native) return;
+ native.Text = value ?? '';
+ }
+
+ [hintProperty.setNative](value: string) {
+ const native = this.nativeViewProtected;
+ if (!native) return;
+ try {
+ native.PlaceholderText = value ?? '';
+ } catch (_e) {}
+ }
+
+ [textFieldBackgroundColorProperty.setNative](value: Color) {
+ try {
+ if (this.nativeViewProtected && value instanceof Color) {
+ this.nativeViewProtected.Background = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never;
+ }
+ } catch (_e) {}
+ }
+
+ [textFieldHintColorProperty.setNative](value: Color) {
+ try {
+ // PlaceholderForeground is available on newer platforms
+ if (this.nativeViewProtected && value instanceof Color && typeof (this.nativeViewProtected as any).PlaceholderForeground !== 'undefined') {
+ (this.nativeViewProtected as any).PlaceholderForeground = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows);
+ }
+ } catch (_e) {}
+ }
+
+ [clearButtonColorProperty.setNative](_value: Color | string) {
+ // No reliable way to style clear button across UWP flavors in a consistent way here.
+ }
+}
+
diff --git a/packages/core/ui/segmented-bar/index.windows.ts b/packages/core/ui/segmented-bar/index.windows.ts
new file mode 100644
index 0000000000..bcf50420b6
--- /dev/null
+++ b/packages/core/ui/segmented-bar/index.windows.ts
@@ -0,0 +1,39 @@
+export * from './segmented-bar-common';
+
+import { SegmentedBarBase, SegmentedBarItemBase } from './segmented-bar-common';
+
+export class SegmentedBarItem extends SegmentedBarItemBase {
+ // Minimal implementation for Windows: update is a no-op for now.
+ public _update(): void {
+ // Windows-specific native mapping for SegmentedBarItem titles
+ // is not fully implemented yet. Avoid throwing when XML builder
+ // sets the `title` property by providing a safe no-op here.
+ }
+}
+
+export class SegmentedBar extends SegmentedBarBase {
+ nativeViewProtected: any;
+ private _isPivotAvailable: boolean = true;
+
+ public createNativeView() {
+ try {
+ const pivot = new Windows.UI.Xaml.Controls.Pivot();
+ this._isPivotAvailable = true;
+ this.nativeViewProtected = pivot;
+ return pivot;
+ } catch (e) {
+ // Pivot not available on some Windows hosts; fallback to a simple Grid
+ try {
+ const grid = new Windows.UI.Xaml.Controls.Grid();
+ this._isPivotAvailable = false;
+ this.nativeViewProtected = grid;
+ return grid;
+ } catch (_e) {
+ // Last resort: return null and avoid throwing during view creation
+ this._isPivotAvailable = false;
+ this.nativeViewProtected = null;
+ return null;
+ }
+ }
+ }
+}
diff --git a/packages/core/ui/slider/index.windows.ts b/packages/core/ui/slider/index.windows.ts
new file mode 100644
index 0000000000..1976688ee1
--- /dev/null
+++ b/packages/core/ui/slider/index.windows.ts
@@ -0,0 +1,189 @@
+export * from './slider-common';
+
+import { Background } from '../styling/background';
+import { SliderBase, valueProperty, minValueProperty, maxValueProperty } from './slider-common';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import { AndroidHelper } from '../core/view';
+import { LinearGradient } from '../styling/linear-gradient';
+
+export class Slider extends SliderBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.Slider;
+ private _windows: Windows.UI.Xaml.Controls.Slider;
+ private _pendingGradient: any = null;
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.Slider();
+ }
+ public createNativeView() {
+ // If a gradient was set before native view creation, apply it now.
+ if (this._pendingGradient) {
+ try { this._applyGradientToTrack(this._pendingGradient); } catch (_e) { }
+ this._pendingGradient = null;
+ }
+ return this._windows;
+ }
+
+ [valueProperty.setNative](value: number) {
+ this.nativeViewProtected.Value = value;
+ }
+
+ [minValueProperty.setNative](value: number) {
+ this.nativeViewProtected.Minimum = value;
+ }
+
+ [maxValueProperty.getDefault](): number {
+ return 100;
+ }
+ [maxValueProperty.setNative](value: number) {
+ this.nativeViewProtected.Maximum = value;
+ }
+
+ [colorProperty.getDefault](): number {
+ return -1;
+ }
+ [colorProperty.setNative](value: number | Color) {
+ if (!this.nativeViewProtected) return;
+ const resources = this.nativeViewProtected.Resources;
+ if (value instanceof Color) {
+ resources.Insert('SliderThumbBackground', new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never);
+ } else {
+ resources.Remove('SliderThumbBackground');
+ }
+ }
+
+ [backgroundColorProperty.getDefault](): number {
+ return -1;
+ }
+ [backgroundColorProperty.setNative](value: number | Color) {
+ if (!this.nativeViewProtected) return;
+ const resources = this.nativeViewProtected.Resources;
+ if (value instanceof Color) {
+ resources.Insert('SliderTrackValueFill', new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never);
+ } else {
+ resources.Remove('SliderTrackValueFill');
+ }
+ }
+
+ [backgroundInternalProperty.getDefault](): Background {
+ return null;
+ }
+ [backgroundInternalProperty.setNative](value: Background) {
+ try { console.log(`[Slider.Windows] backgroundInternal.setNative called for view=${(this && (this as any).constructor && (this as any).constructor.name) || '(Slider)'} hasImage=${!!(value && value.image)}`); } catch (_e) {}
+ // If native view isn't created yet, stash the gradient for later.
+ if (!this.nativeViewProtected) {
+ if (value && value.image) {
+ this._pendingGradient = (value as any).image;
+ } else {
+ this._pendingGradient = null;
+ }
+ return;
+ }
+ const resources = this.nativeViewProtected.Resources;
+ if (value && value.image) {
+ const image = value.image as any;
+ if (image instanceof LinearGradient || (image && image.colorStops)) {
+ this._applyGradientToTrack(image);
+ return;
+ }
+ }
+ // No usable gradient — remove any previously inserted resources
+ try { resources.Remove('SliderTrackValueFill'); resources.Remove('SliderTrackBackgroundFill'); } catch (_e) { }
+ }
+
+ private _applyGradientToTrack(gradient: LinearGradient | any): void {
+ const nativeView = this.nativeViewProtected;
+ if (!nativeView || !gradient || !gradient.colorStops || gradient.colorStops.length === 0) {
+ try { console.log(`[Slider.Windows] _applyGradientToTrack skipped: no gradient or stops`); } catch (_e) {}
+ return;
+ }
+ try { console.log(`[Slider.Windows] _applyGradientToTrack applying ${gradient.colorStops.length} stops`); } catch (_e) {}
+
+ const resources = nativeView.Resources;
+
+ // Helper to map CSS angle to StartPoint/EndPoint
+ const angle = typeof gradient.angle === 'number' ? gradient.angle : 0;
+ const rad = (angle * Math.PI) / 180;
+ const dx = Math.cos(rad);
+ const dy = Math.sin(rad);
+ const startPt = Windows.UI.Xaml.PointHelper.FromCoordinates(0.5 - dx / 2, 0.5 - dy / 2);
+ const endPt = Windows.UI.Xaml.PointHelper.FromCoordinates(0.5 + dx / 2, 0.5 + dy / 2);
+
+ // Build filled (value) gradient brush
+ const valueBrush = new Windows.UI.Xaml.Media.LinearGradientBrush();
+ valueBrush.StartPoint = startPt;
+ valueBrush.EndPoint = endPt;
+ for (let i = 0; i < gradient.colorStops.length; i++) {
+ const stop = gradient.colorStops[i];
+ const gs = new Windows.UI.Xaml.Media.GradientStop();
+ // If the stop already provides a Windows color (via `Color.windows`), use it directly
+ let winColor: any = null;
+ if (stop.color && (stop.color as any).windows) {
+ winColor = (stop.color as any).windows;
+ } else {
+ const c = stop.color || { r: 0, g: 0, b: 0, a: 255 };
+ // Support colors specified as 0..1 normalized or 0..255 integers.
+ const normalizeChannel = (v: any) => {
+ if (typeof v !== 'number') return 0;
+ if (v <= 1) return Math.round(v * 255);
+ return Math.round(v);
+ };
+ const aCh = normalizeChannel(c.a ?? 255);
+ const rCh = normalizeChannel(c.r ?? 0);
+ const gCh = normalizeChannel(c.g ?? 0);
+ const bCh = normalizeChannel(c.b ?? 0);
+ winColor = Windows.UI.ColorHelper.FromArgb(aCh, rCh, gCh, bCh);
+ }
+ gs.Color = winColor;
+ if (stop.offset && (stop.offset as any).unit === '%') {
+ const v = (stop.offset as any).value || 0;
+ gs.Offset = Math.max(0, Math.min(1, v / 100));
+ } else {
+ gs.Offset = i / Math.max(1, gradient.colorStops.length - 1);
+ }
+ valueBrush.GradientStops.Append(gs);
+ try {
+ const hex = '#' + ('000000' + ((winColor.A << 24) >>> 0 | (winColor.R << 16) | (winColor.G << 8) | winColor.B).toString(16).toUpperCase()).slice(-8);
+ console.log(`[Slider.Windows] Gradient stop ${i}: r=${c.r} g=${c.g} b=${c.b} a=${c.a} -> ${hex}`);
+ } catch (_e) { }
+ }
+
+ // Build background (faded) gradient brush
+ const bgBrush = new Windows.UI.Xaml.Media.LinearGradientBrush();
+ bgBrush.StartPoint = startPt;
+ bgBrush.EndPoint = endPt;
+ for (let i = 0; i < gradient.colorStops.length; i++) {
+ const stop = gradient.colorStops[i];
+ const gs = new Windows.UI.Xaml.Media.GradientStop();
+ let r: number, g: number, b: number, aRaw: number;
+ if (stop.color && (stop.color as any).windows) {
+ const wc = (stop.color as any).windows;
+ r = wc.R; g = wc.G; b = wc.B; aRaw = wc.A;
+ } else {
+ const c = stop.color || { r: 0, g: 0, b: 0, a: 255 };
+ const normalizeChannel = (v: any) => {
+ if (typeof v !== 'number') return 0;
+ if (v <= 1) return Math.round(v * 255);
+ return Math.round(v);
+ };
+ r = normalizeChannel(c.r ?? 0);
+ g = normalizeChannel(c.g ?? 0);
+ b = normalizeChannel(c.b ?? 0);
+ aRaw = normalizeChannel(c.a ?? 255);
+ }
+ const a = Math.max(0, Math.min(255, Math.round(aRaw * 0.3)));
+ gs.Color = Windows.UI.ColorHelper.FromArgb(a, r, g, b);
+ if (stop.offset && (stop.offset as any).unit === '%') {
+ const v = (stop.offset as any).value || 0;
+ gs.Offset = Math.max(0, Math.min(1, v / 100));
+ } else {
+ gs.Offset = i / Math.max(1, gradient.colorStops.length - 1);
+ }
+ bgBrush.GradientStops.Append(gs);
+ }
+
+ resources.Insert('SliderTrackValueFill', valueBrush as never);
+ resources.Insert('SliderTrackBackgroundFill', bgBrush as never);
+
+ }
+}
diff --git a/packages/core/ui/split-view/index.windows.ts b/packages/core/ui/split-view/index.windows.ts
new file mode 100644
index 0000000000..fa480f4f43
--- /dev/null
+++ b/packages/core/ui/split-view/index.windows.ts
@@ -0,0 +1,646 @@
+export * from './split-view-common';
+
+import { SplitViewBase, displayModeProperty, splitBehaviorProperty, preferredPrimaryColumnWidthFractionProperty, preferredSupplementaryColumnWidthFractionProperty, preferredInspectorColumnWidthFractionProperty, navigationBarTintColorProperty } from './split-view-common';
+import { View } from '../core/view';
+import { layout } from '../../utils';
+import { FrameBase } from '../frame/frame-common';
+import { Color } from '../../color';
+import type { SplitRole } from '.';
+
+export class SplitView extends SplitViewBase {
+ static instance: SplitView;
+ static getInstance(): SplitViewBase | null {
+ return SplitView.instance;
+ }
+ primaryButtonAttached = false;
+ inspectorButtonAttached = false;
+ inspectorShowing = false;
+ primaryShowing = true;
+ nativeViewProtected: Windows.UI.Xaml.Controls.Grid;
+ private _grid: Windows.UI.Xaml.Controls.Grid;
+ // role -> container/native element and role -> child view
+ private _containers = new Map();
+ private _children = new Map();
+
+ constructor() {
+ super();
+ this._grid = new Windows.UI.Xaml.Controls.Grid();
+ try { this._grid.HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch; } catch (_e) {}
+ try { this._grid.VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Stretch; } catch (_e) {}
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.Grid {
+ return this._grid;
+ }
+
+ public createNativeView() {
+ SplitView.instance = this;
+ try { this.nativeViewProtected = this._grid; } catch (_e) {}
+ return this._grid;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView && super.initNativeView();
+ this._applyPreferences();
+ }
+
+ public disposeNativeView(): void {
+ try {
+ if (this._grid) {
+ try { (this._grid as any).ColumnDefinitions.Clear(); } catch (_e) {}
+ try { (this._grid as any).Children.Clear(); } catch (_e) {}
+ }
+ } catch (_e) {}
+
+ this._containers.clear();
+ this._children.clear();
+ SplitView.instance = null;
+ this._grid = null;
+ super.disposeNativeView && super.disposeNativeView();
+ }
+
+ public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+ // Call base implementation so the native/logic parent relationships and layout
+ // bookkeeping are performed. This ensures measurement and layout work correctly.
+ let res = true;
+ try { res = super._addViewToNativeVisualTree(child, atIndex); } catch (_e) { res = true; }
+
+ try {
+ const role = this._resolveRoleForChild(child, atIndex);
+ // Register logical child mapping so consumers can find it
+ this._children.set(role, child);
+
+ const nativeChild = (child as any).nativeViewProtected as any;
+ // Store native child as the container for this role (avoid wrapping/reparenting)
+ let container = this._containers.get(role);
+ if (!container && nativeChild) {
+ // nativeChild was appended to this._grid by super; keep it there and track it
+ try { nativeChild.HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch; } catch (_e) {}
+ try { nativeChild.VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Stretch; } catch (_e) {}
+ this._containers.set(role, nativeChild);
+ container = nativeChild;
+ }
+
+ // Lightweight debug: walk the native child's subtree to locate ListView-like elements
+ if (nativeChild) {
+ try {
+ const walk = (node: any, depth = 0) => {
+ if (!node || depth > 6) return;
+ try {
+ const ctor = node && node.constructor ? node.constructor.name : null;
+ try { console.log('[SplitView] native node', depth, ctor || (node as any).GetType?.Name || 'unknown'); } catch (_e) {}
+ } catch (_e) {}
+ try {
+ const children = node.Children as any;
+ if (children && typeof children.Size === 'number') {
+ for (let i = 0; i < (children.Size ?? 0); i++) {
+ try { walk(children.GetAt(i), depth + 1); } catch (_e) {}
+ }
+ } else {
+ // If leaf, check for Items/ItemsSource
+ try { if ((node as any).Items) { console.log('[SplitView] found Items with Size=', (node as any).Items?.Size ?? 'unknown'); } } catch (_e) {}
+ try { if ((node as any).ItemsSource) { console.log('[SplitView] found ItemsSource'); } } catch (_e) {}
+ }
+ } catch (_e) {}
+ };
+ walk(nativeChild);
+ } catch (_e) {}
+ }
+
+ this._syncColumns();
+
+ // Ensure native layout pass occurs so children (ListView, Pages) can measure and render.
+ try { Windows.UI.Xaml.Controls.Grid.SetRow(container, 0); } catch (_e) {}
+ try { (container as any).InvalidateMeasure && (container as any).InvalidateMeasure(); } catch (_e) {}
+ try { (container as any).UpdateLayout && (container as any).UpdateLayout(); } catch (_e) {}
+ try { (this._grid as any).InvalidateMeasure && (this._grid as any).InvalidateMeasure(); } catch (_e) {}
+ try { (this._grid as any).UpdateLayout && (this._grid as any).UpdateLayout(); } catch (_e) {}
+ this._invalidateAllChildLayouts();
+ } catch (_e) {}
+
+ return res;
+ }
+
+ public _removeViewFromNativeVisualTree(child: View): void {
+ try {
+ const role = this._findRoleByChild(child);
+ if (role) {
+ const container = this._containers.get(role);
+ if (container) {
+ // Remove the container element (could be a native child or a wrapper grid)
+ try { (this._grid as any).Children.Remove(container); } catch (_e) {}
+ }
+ // Cleanup any attached buttons/handlers on the removed child
+ try {
+ const childView: any = child as any;
+ const cmdBar = this._findCommandBarFor(childView);
+
+ if (childView._splitViewPrimaryNavigatedHandler) {
+ try { childView.off && childView.off(FrameBase.navigatedToEvent, childView._splitViewPrimaryNavigatedHandler); } catch (_e) {}
+ childView._splitViewPrimaryNavigatedHandler = null;
+ }
+ if (childView._splitViewPrimaryButton && cmdBar) {
+ try {
+ const cmds = (cmdBar as any).PrimaryCommands;
+ const size = cmds?.Size ?? 0;
+ for (let i = size - 1; i >= 0; i--) {
+ try { if (cmds.GetAt(i) === childView._splitViewPrimaryButton) { cmds.RemoveAt(i); break; } } catch (_e) {}
+ }
+ } catch (_e) {}
+ childView._splitViewPrimaryButton = null;
+ this.primaryButtonAttached = false;
+ }
+
+ if (childView._splitViewNavigatedHandler) {
+ try { childView.off && childView.off(FrameBase.navigatedToEvent, childView._splitViewNavigatedHandler); } catch (_e) {}
+ childView._splitViewNavigatedHandler = null;
+ }
+ if (childView._splitViewInspectorButton && cmdBar) {
+ try {
+ const cmds = (cmdBar as any).PrimaryCommands;
+ const size = cmds?.Size ?? 0;
+ for (let i = size - 1; i >= 0; i--) {
+ try { if (cmds.GetAt(i) === childView._splitViewInspectorButton) { cmds.RemoveAt(i); break; } } catch (_e) {}
+ }
+ } catch (_e) {}
+ childView._splitViewInspectorButton = null;
+ this.inspectorButtonAttached = false;
+ }
+ } catch (_e) {}
+
+ this._containers.delete(role);
+ this._children.delete(role);
+ this._syncColumns();
+ }
+ } catch (_e) {}
+
+ super._removeViewFromNativeVisualTree(child);
+ }
+
+ public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+ super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+ const width = layout.getMeasureSpecSize(widthMeasureSpec);
+ const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+ const height = layout.getMeasureSpecSize(heightMeasureSpec);
+ const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+ const horizontal = this.effectivePaddingLeft + this.effectivePaddingRight + this.effectiveBorderLeftWidth + this.effectiveBorderRightWidth;
+ const vertical = this.effectivePaddingTop + this.effectivePaddingBottom + this.effectiveBorderTopWidth + this.effectiveBorderBottomWidth;
+
+ const measuredWidth = Math.max(widthMode === layout.UNSPECIFIED ? 0 : width, this.effectiveMinWidth) + (widthMode === layout.UNSPECIFIED ? horizontal : 0);
+ const measuredHeight = Math.max(heightMode === layout.UNSPECIFIED ? 0 : height, this.effectiveMinHeight) + (heightMode === layout.UNSPECIFIED ? vertical : 0);
+
+ const widthAndState = View.resolveSizeAndState(measuredWidth, width, widthMode, 0);
+ const heightAndState = View.resolveSizeAndState(measuredHeight, height, heightMode, 0);
+ this.setMeasuredDimension(widthAndState, heightAndState);
+ }
+
+ public _invalidateAllChildLayouts(): void {
+ // Wait a short time to allow native transitions to finish
+ setTimeout(() => this.invalidateChildLayouts(), 350);
+ }
+
+ invalidateChildLayouts(delay: number = 0): void {
+ const refreshLayouts = () => {
+ for (const [role, child] of this._children.entries()) {
+ try { child.requestLayout && child.requestLayout(); } catch (_e) {}
+ try {
+ const native = (child as any).nativeViewProtected as any;
+ if (native) {
+ try { native.InvalidateMeasure && native.InvalidateMeasure(); } catch (_e) {}
+ try { native.UpdateLayout && native.UpdateLayout(); } catch (_e) {}
+ }
+ } catch (_e) {}
+
+ if ((child as FrameBase)?.currentPage?.requestLayout) {
+ try { (child as FrameBase).currentPage.requestLayout(); } catch (_e) {}
+ try {
+ const np = (child as FrameBase).currentPage.nativeViewProtected as any;
+ if (np) {
+ try { np.InvalidateMeasure && np.InvalidateMeasure(); } catch (_e) {}
+ try { np.UpdateLayout && np.UpdateLayout(); } catch (_e) {}
+ }
+ } catch (_e) {}
+ }
+ }
+
+ try { this.requestLayout(); } catch (_e) {}
+ try {
+ if (this._grid) {
+ try { (this._grid as any).InvalidateMeasure && (this._grid as any).InvalidateMeasure(); } catch (_e) {}
+ try { (this._grid as any).UpdateLayout && (this._grid as any).UpdateLayout(); } catch (_e) {}
+ }
+ } catch (_e) {}
+ };
+
+ if (delay > 0) {
+ setTimeout(refreshLayouts, delay);
+ } else {
+ refreshLayouts();
+ }
+ }
+
+ private _resolveRoleForChild(child: SplitViewBase, atIndex: number): SplitRole {
+ const explicit = SplitViewBase.getRole(child);
+ if (explicit) return explicit;
+ return this._roleByIndex(atIndex) as SplitRole;
+ }
+
+ private _findRoleByChild(child: View): SplitRole | null {
+ for (const [role, c] of this._children.entries()) {
+ if (c === child) return role;
+ }
+ return null;
+ }
+
+ private _syncColumns(): void {
+ if (!this._grid) return;
+
+ try {
+ const ORDER: SplitRole[] = ['primary', 'secondary', 'supplementary', 'inspector'];
+ try { console.log('[SplitView] _syncColumns start'); } catch (_e) {}
+ const activeRoles = ORDER.filter((r) => this._children.has(r));
+ try { console.log('[SplitView] activeRoles=', activeRoles); } catch (_e) {}
+
+ // Build fractions map
+ const specified = new Map();
+ let sumSpecified = 0;
+ if (activeRoles.indexOf('primary') >= 0 && typeof this.preferredPrimaryColumnWidthFraction === 'number' && this.preferredPrimaryColumnWidthFraction > 0) {
+ specified.set('primary', this.preferredPrimaryColumnWidthFraction);
+ sumSpecified += this.preferredPrimaryColumnWidthFraction;
+ }
+ if (activeRoles.indexOf('supplementary') >= 0 && typeof this.preferredSupplementaryColumnWidthFraction === 'number' && this.preferredSupplementaryColumnWidthFraction > 0) {
+ specified.set('supplementary', this.preferredSupplementaryColumnWidthFraction);
+ sumSpecified += this.preferredSupplementaryColumnWidthFraction;
+ }
+ if (activeRoles.indexOf('inspector') >= 0 && typeof this.preferredInspectorColumnWidthFraction === 'number' && this.preferredInspectorColumnWidthFraction > 0) {
+ specified.set('inspector', this.preferredInspectorColumnWidthFraction);
+ sumSpecified += this.preferredInspectorColumnWidthFraction;
+ }
+
+ const unspecifiedCount = activeRoles.length - specified.size;
+ const remaining = Math.max(0, 1 - sumSpecified);
+
+ const fractions: number[] = [];
+ for (const role of activeRoles) {
+ if (specified.has(role)) {
+ fractions.push(specified.get(role));
+ } else {
+ fractions.push(unspecifiedCount > 0 ? remaining / unspecifiedCount : 0);
+ }
+ }
+ try { console.log('[SplitView] fractions=', fractions); } catch (_e) {}
+
+ // Create ColumnDefinitions
+ const colDefs: any[] = [];
+ for (let i = 0; i < fractions.length; i++) {
+ try {
+ const cd = new Windows.UI.Xaml.Controls.ColumnDefinition();
+ // Use star sizing based on fraction weight
+ const weight = fractions[i] > 0 ? fractions[i] : 1;
+ cd.Width = new Windows.UI.Xaml.GridLength(weight, Windows.UI.Xaml.GridUnitType.star);
+ colDefs.push(cd);
+ } catch (_e) {}
+ }
+
+ // Replace native column definitions
+ try { (this._grid as any).ColumnDefinitions.ReplaceAll(colDefs); } catch (_e) {
+ try { (this._grid as any).ColumnDefinitions.Clear(); } catch (_e2) {}
+ for (const cd of colDefs) {
+ try { (this._grid as any).ColumnDefinitions.Append(cd); } catch (_e3) {}
+ }
+ }
+ try { console.log('[SplitView] applied', colDefs.length, 'ColumnDefinitions'); } catch (_e) {}
+
+ // Ensure containers are in correct columns and present
+ for (let i = 0; i < activeRoles.length; i++) {
+ const role = activeRoles[i];
+ let container = this._containers.get(role);
+ if (!container) {
+ container = new Windows.UI.Xaml.Controls.Grid();
+ container.HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Stretch;
+ container.VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Stretch;
+ this._containers.set(role, container);
+ try { (this._grid as any).Children.Append(container); } catch (_e) {}
+ }
+ try { Windows.UI.Xaml.Controls.Grid.SetColumn(container, i); } catch (_e) {}
+ }
+ try {
+ for (let i = 0; i < activeRoles.length; i++) {
+ const role = activeRoles[i];
+ const container = this._containers.get(role) as any;
+ const ctorName = container && container.constructor ? (container.constructor.name || (container as any).GetType?.Name) : 'none';
+ const childCount = container ? (container.Children?.Size ?? 0) : 0;
+ try { console.log('[SplitView] container', role, 'ctor=', ctorName, 'children=', childCount); } catch (_e) {}
+ }
+ } catch (_e) {}
+
+ // Remove any containers for roles no longer active
+ for (const [role, container] of Array.from(this._containers.entries())) {
+ if (activeRoles.indexOf(role) === -1) {
+ try { (this._grid as any).Children.Remove(container); } catch (_e) {}
+ this._containers.delete(role);
+ }
+ }
+
+ this._applyPreferences();
+ } catch (_e) {}
+ }
+
+ private _applyPreferences(): void {
+ if (!this._grid) return;
+
+ try {
+ // Ensure column visibility according to simple displayMode heuristics
+ const ORDER: SplitRole[] = ['primary', 'secondary', 'supplementary', 'inspector'];
+ const activeRoles = ORDER.filter((r) => this._children.has(r));
+
+ // Update column widths if ColumnDefinitions exist
+ const cols = (this._grid as any).ColumnDefinitions as any;
+ const colCount = cols?.Size ?? 0;
+ for (let i = 0; i < colCount; i++) {
+ try {
+ const cd = cols.GetAt(i);
+ // keep existing star sizing; nothing to change per-column here since _syncColumns sets fractions
+ } catch (_e) {}
+ }
+
+ // Show/hide specific columns based on explicit show/hide calls by client
+ // (Client code should call showPrimary/hidePrimary etc.)
+ // If preferred fractions are set, we already applied them in _syncColumns
+ // Attach toggle buttons to Frame command bars when possible (methods defined at class scope)
+ try {
+ const primary = this._children.get('primary');
+ if (primary) {
+ this.attachPrimaryButton();
+ }
+ const inspector = this._children.get('inspector');
+ if (inspector) {
+ this.attachInspectorButton();
+ }
+ } catch (_e) {}
+
+ // Show/hide specific columns based on explicit show/hide calls by client
+ // (Client code should call showPrimary/hidePrimary etc.)
+ // If preferred fractions are set, we already applied them in _syncColumns
+ // Attach toggle buttons to Frame command bars when possible
+ try {
+ const primary = this._children.get('primary');
+ if (primary) {
+ this.attachPrimaryButton();
+ }
+ const inspector = this._children.get('inspector');
+ if (inspector) {
+ this.attachInspectorButton();
+ }
+ } catch (_e) {}
+ } catch (_e) {}
+ }
+
+ showPrimary(): void {
+ const container = this._containers.get('primary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Visible; } catch (_e) {}
+ this.primaryShowing = true;
+ this._invalidateAllChildLayouts();
+ }
+
+ hidePrimary(): void {
+ const container = this._containers.get('primary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Collapsed; } catch (_e) {}
+ this.primaryShowing = false;
+ this._invalidateAllChildLayouts();
+ }
+
+ showSecondary(): void {
+ const container = this._containers.get('secondary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Visible; } catch (_e) {}
+ this._invalidateAllChildLayouts();
+ }
+
+ hideSecondary(): void {
+ const container = this._containers.get('secondary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Collapsed; } catch (_e) {}
+ this._invalidateAllChildLayouts();
+ }
+
+ showSupplementary(): void {
+ const container = this._containers.get('supplementary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Visible; } catch (_e) {}
+ this._invalidateAllChildLayouts();
+ }
+
+ hideSupplementary(): void {
+ const container = this._containers.get('supplementary');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Collapsed; } catch (_e) {}
+ this._invalidateAllChildLayouts();
+ }
+
+ showInspector(): void {
+ const container = this._containers.get('inspector');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Visible; } catch (_e) {}
+ this.notifyInspectorChange(true);
+ this._invalidateAllChildLayouts();
+ }
+
+ hideInspector(): void {
+ const container = this._containers.get('inspector');
+ if (!container) return;
+ try { container.Visibility = Windows.UI.Xaml.Visibility.Collapsed; } catch (_e) {}
+ this.notifyInspectorChange(false);
+ this._invalidateAllChildLayouts();
+ }
+
+ notifyInspectorChange(showing: boolean): void {
+ this.inspectorShowing = showing;
+ this.notify({
+ eventName: 'inspectorChange',
+ object: this,
+ data: { showing },
+ });
+ }
+
+ private _findCommandBarFor(childView: any): any {
+ try {
+ const native = (childView && (childView.nativeViewProtected || childView.windows || childView)) as any;
+ if (!native) return null;
+ const visited = new Set();
+ const walk = (node: any, depth = 0): any => {
+ if (!node || depth > 8 || visited.has(node)) return null;
+ visited.add(node);
+ try { if ((node as any).PrimaryCommands !== undefined) return node; } catch (_e) {}
+ try {
+ const children = node.Children as any;
+ if (children && typeof children.Size === 'number') {
+ for (let i = 0; i < (children.Size ?? 0); i++) {
+ try {
+ const el = children.GetAt(i);
+ const found = walk(el, depth + 1);
+ if (found) return found;
+ } catch (_e) {}
+ }
+ }
+ } catch (_e) {}
+ return null;
+ };
+ return walk(native, 0);
+ } catch (_e) {}
+ return null;
+ }
+
+ private attachPrimaryButton(): void {
+ if (this.primaryButtonAttached) return;
+
+ const primaryChild = this._children.get('primary') as any;
+ if (!primaryChild) return;
+
+ const cmdBar = this._findCommandBarFor(primaryChild);
+ if (!cmdBar) {
+ // Wait for frame navigation so the command bar exists
+ if (primaryChild && primaryChild.on && !primaryChild._splitViewPrimaryNavigatedHandler) {
+ primaryChild._splitViewPrimaryNavigatedHandler = () => {
+ setTimeout(() => this.attachPrimaryButton(), 0);
+ };
+ try { primaryChild.on(FrameBase.navigatedToEvent, primaryChild._splitViewPrimaryNavigatedHandler); } catch (_e) {}
+ }
+ return;
+ }
+
+ // Avoid duplicates
+ if (primaryChild._splitViewPrimaryButton) return;
+
+ try {
+ const btn = new (Windows.UI.Xaml.Controls as any).AppBarButton();
+ try {
+ const fontIcon = new Windows.UI.Xaml.Controls.FontIcon();
+ fontIcon.Glyph = '\u2630';
+ (btn as any).Icon = fontIcon;
+ } catch (_e) {}
+
+ const that = new WeakRef(this);
+ let delegate: any = null;
+ try {
+ delegate = new Windows.UI.Xaml.RoutedEventHandler(() => {
+ const owner = that.deref();
+ if (!owner) return;
+ if (owner.primaryShowing) {
+ owner.hidePrimary();
+ owner.primaryShowing = false;
+ } else {
+ owner.showPrimary();
+ owner.primaryShowing = true;
+ }
+ });
+ (btn as any).Click = delegate as never;
+ } catch (_e) {
+ delegate = () => {
+ const owner = that.deref();
+ if (!owner) return;
+ if (owner.primaryShowing) {
+ owner.hidePrimary();
+ owner.primaryShowing = false;
+ } else {
+ owner.showPrimary();
+ owner.primaryShowing = true;
+ }
+ };
+ try { (btn as any).Click = delegate as never; } catch (_e2) { try { if (typeof (btn as any).addEventListener === 'function') (btn as any).addEventListener('click', delegate); } catch (_e3) {} }
+ }
+
+ try { (cmdBar as any).PrimaryCommands.Append(btn); } catch (_e) {}
+ primaryChild._splitViewPrimaryButton = btn;
+ this.primaryButtonAttached = true;
+ } catch (_e) {}
+ }
+
+ private attachInspectorButton(): void {
+ if (this.inspectorButtonAttached) return;
+
+ const inspectorChild = this._children.get('inspector') as any;
+ if (!inspectorChild) return;
+
+ const cmdBar = this._findCommandBarFor(inspectorChild);
+ if (!cmdBar) {
+ if (inspectorChild && inspectorChild.on && !inspectorChild._splitViewNavigatedHandler) {
+ inspectorChild._splitViewNavigatedHandler = () => {
+ setTimeout(() => this.attachInspectorButton(), 100);
+ };
+ try { inspectorChild.on(FrameBase.navigatedToEvent, inspectorChild._splitViewNavigatedHandler); } catch (_e) {}
+ }
+ return;
+ }
+
+ if (inspectorChild._splitViewInspectorButton) return;
+
+ try {
+ const btn = new (Windows.UI.Xaml.Controls as any).AppBarButton();
+ try {
+ const fontIcon = new Windows.UI.Xaml.Controls.FontIcon();
+ fontIcon.Glyph = '\u25A3';
+ (btn as any).Icon = fontIcon;
+ } catch (_e) {}
+
+ const that = new WeakRef(this);
+ let delegate: any = null;
+ try {
+ delegate = new Windows.UI.Xaml.RoutedEventHandler(() => {
+ const owner = that.deref();
+ if (!owner) return;
+ if (owner.inspectorShowing) {
+ owner.hideInspector();
+ } else {
+ owner.showInspector();
+ }
+ });
+ (btn as any).Click = delegate as never;
+ } catch (_e) {
+ delegate = () => {
+ const owner = that.deref();
+ if (!owner) return;
+ if (owner.inspectorShowing) {
+ owner.hideInspector();
+ } else {
+ owner.showInspector();
+ }
+ };
+ try { (btn as any).Click = delegate as never; } catch (_e2) { try { if (typeof (btn as any).addEventListener === 'function') (btn as any).addEventListener('click', delegate); } catch (_e3) {} }
+ }
+
+ try { (cmdBar as any).PrimaryCommands.Append(btn); } catch (_e) {}
+ inspectorChild._splitViewInspectorButton = btn;
+ this.inspectorButtonAttached = true;
+ } catch (_e) {}
+ }
+
+ [displayModeProperty.setNative](value: string) {
+ this._syncColumns();
+ }
+
+ [splitBehaviorProperty.setNative](value: string) {
+ this._syncColumns();
+ }
+
+ [preferredPrimaryColumnWidthFractionProperty.setNative](value: number) {
+ this._syncColumns();
+ }
+
+ [preferredSupplementaryColumnWidthFractionProperty.setNative](value: number) {
+ this._syncColumns();
+ }
+
+ [preferredInspectorColumnWidthFractionProperty.setNative](value: number) {
+ this._syncColumns();
+ }
+
+ [navigationBarTintColorProperty.setNative](value: Color) {
+ // No-op on Windows for now; keep API parity
+ }
+}
+
diff --git a/packages/core/ui/styling/background.windows.ts b/packages/core/ui/styling/background.windows.ts
new file mode 100644
index 0000000000..b4a5979fe5
--- /dev/null
+++ b/packages/core/ui/styling/background.windows.ts
@@ -0,0 +1,3 @@
+export * from './background-common';
+
+export namespace windows {}
\ No newline at end of file
diff --git a/packages/core/ui/styling/font.windows.ts b/packages/core/ui/styling/font.windows.ts
new file mode 100644
index 0000000000..6a0fe02d8a
--- /dev/null
+++ b/packages/core/ui/styling/font.windows.ts
@@ -0,0 +1,146 @@
+import { Font as FontBase, parseFontFamily, genericFontFamilies, FontWeight, FontVariationSettings, FONTS_BASE_PATH } from './font-common';
+import type { FontStyleType, FontWeightType, FontVariationSettingsType } from './font-interfaces';
+
+export * from './font-common';
+
+
+export const fontFamilyCache = new Map();
+
+function sanitizeFontFamily(raw: string): string {
+ if (!raw) return '';
+ let f = String(raw).trim();
+ if ((f.startsWith('"') && f.endsWith('"')) || (f.startsWith("'") && f.endsWith("'"))) {
+ f = f.substring(1, f.length - 1);
+ }
+ const commaIdx = f.indexOf(',');
+ if (commaIdx >= 0) f = f.substring(0, commaIdx).trim();
+ // Strip common scheme prefixes (e.g. font://, sys://)
+ f = f.replace(/^[a-zA-Z]+:\/\//, '');
+ return f;
+}
+
+function createFontFamilyCandidate(candidate: string): Windows.UI.Xaml.Media.FontFamily | null {
+ if (!candidate) return null;
+ try {
+ if (fontFamilyCache.has(candidate)) {
+ return fontFamilyCache.get(candidate) ?? null;
+ }
+
+ const ff = new Windows.UI.Xaml.Media.FontFamily(candidate);
+ try { console.log(`[Font] Created FontFamily "${candidate}" -> source="${ff.Source}"`); } catch (_e) {}
+ fontFamilyCache.set(candidate, ff);
+ return ff;
+ } catch (err) {
+ console.log(`[Font] FontFamily creation failed for "${candidate}":`, err);
+ fontFamilyCache.set(candidate, null);
+ return null;
+ }
+}
+
+export function getFontFamilyCached(family: string): Windows.UI.Xaml.Media.FontFamily | null {
+ const candidate = sanitizeFontFamily(String(family || ''));
+ if (!candidate) return null;
+
+ if (fontFamilyCache.has(candidate)) {
+ return fontFamilyCache.get(candidate) ?? null;
+ }
+
+ const created = createFontFamilyCandidate(candidate);
+ if (created) return created;
+
+ // If looks like a relative path, try ms-appx:/// fallback
+ if (!candidate.includes('#') && (candidate.includes('/') || candidate.includes('\\'))) {
+ const appx = 'ms-appx:///' + candidate.replace(/^\/+/, '');
+ const created2 = createFontFamilyCandidate(appx);
+ if (created2) return created2;
+ }
+
+ return null;
+}
+
+export function applyFontFamilyTo(target: any, fontFamilyValue: string): void {
+ if (!target || !fontFamilyValue) return;
+
+ const candidate = sanitizeFontFamily(String(fontFamilyValue || ''));
+ if (!candidate) return;
+
+ const candidates = [candidate];
+ if (!candidate.includes('#') && (candidate.includes('/') || candidate.includes('\\'))) {
+ candidates.push('ms-appx:///' + candidate.replace(/^\/+/, ''));
+ }
+
+ for (const c of candidates) {
+ const ff = createFontFamilyCandidate(c);
+ if (ff) {
+ try {
+ target.FontFamily = ff;
+ } catch (_e) {
+ // ignore if target does not accept FontFamily assignment
+ }
+ return;
+ }
+ }
+}
+
+export function clearFontFamilyCache(): void {
+ fontFamilyCache.clear();
+}
+
+export class Font extends FontBase {
+ static default = new Font('', 0);
+
+ constructor(family: string, size: number, style?: FontStyleType, weight?: FontWeightType, scale?: number, variationSettings?: Array) {
+ super(family, size, style, weight, scale, variationSettings ?? undefined);
+ }
+
+ public withFontFamily(family: string): Font {
+ return new Font(family, this.fontSize, this.fontStyle, this.fontWeight, 1, this.fontVariationSettings ?? undefined);
+ }
+
+ public withFontStyle(style: FontStyleType): Font {
+ return new Font(this.fontFamily, this.fontSize, style, this.fontWeight, this.fontScale, this.fontVariationSettings ?? undefined);
+ }
+
+ public withFontWeight(weight: FontWeightType): Font {
+ return new Font(this.fontFamily, this.fontSize, this.fontStyle, weight, this.fontScale, this.fontVariationSettings ?? undefined);
+ }
+
+ public withFontSize(size: number): Font {
+ return new Font(this.fontFamily, size, this.fontStyle, this.fontWeight, this.fontScale, this.fontVariationSettings ?? undefined);
+ }
+
+ public withFontScale(scale: number): Font {
+ return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, scale, this.fontVariationSettings ?? undefined);
+ }
+
+ public withFontVariationSettings(variationSettings?: Array): Font {
+ return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, this.fontScale, variationSettings ?? undefined);
+ }
+
+ public getAndroidTypeface(): any {
+ return undefined;
+ }
+
+ getWindowsFontDescriptor(defaultFont: any): any {
+ const families = parseFontFamily(this.fontFamily);
+ const fontSize = this.fontSize ? this.fontSize * (this.fontScale ?? 1) : (defaultFont?.pointSize ?? 0);
+
+ return {
+ fontFamily: families,
+ fontFamilyNative: getFontFamilyCached(this.fontFamily),
+ fontSize,
+ fontWeight: this.fontWeight ?? FontWeight.NORMAL,
+ fontVariationSettings: this.fontVariationSettings ?? undefined,
+ isBold: this.isBold,
+ isItalic: this.isItalic,
+ } as any;
+ }
+
+ applyWindowsFont(target: any) {
+ applyFontFamilyTo(target, this.fontFamily);
+ }
+
+ public getUIFont(defaultFont: any): any {
+ return undefined;
+ }
+}
diff --git a/packages/core/ui/styling/style-properties.ts b/packages/core/ui/styling/style-properties.ts
index bb65f7f602..b41f65b676 100644
--- a/packages/core/ui/styling/style-properties.ts
+++ b/packages/core/ui/styling/style-properties.ts
@@ -686,6 +686,8 @@ export const backgroundPositionProperty = new CssProperty({
});
backgroundPositionProperty.register(Style);
+
+
// Border Color properties.
const borderColorProperty = new ShorthandProperty({
name: 'borderColor',
diff --git a/packages/core/ui/switch/index.windows.ts b/packages/core/ui/switch/index.windows.ts
new file mode 100644
index 0000000000..cf3f421bab
--- /dev/null
+++ b/packages/core/ui/switch/index.windows.ts
@@ -0,0 +1,147 @@
+export * from './switch-common';
+
+import { SwitchBase, checkedProperty, offBackgroundColorProperty } from './switch-common';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+
+
+/* other states to handle
+//hover
+ToggleSwitchFillOnPointerOver
+ToggleSwitchFillOffPointerOver
+
+// thumb
+ToggleSwitchKnobFillOnPointerOver
+ToggleSwitchKnobFillOffPointerOver
+
+
+// Pressed
+ToggleSwitchFillOnPressed
+ToggleSwitchFillOffPressed
+
+// Disabled
+ToggleSwitchFillOnDisabled
+ToggleSwitchFillOffDisabled
+*/
+
+export class Switch extends SwitchBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.ToggleSwitch;
+ private _toggledHandler: any = null;
+ private _toggledHandlerUsedAddListener: boolean = false;
+ private _windows: Windows.UI.Xaml.Controls.ToggleSwitch;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.ToggleSwitch();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.ToggleSwitch {
+ return this._windows;
+ }
+
+ public initNativeView(): void {
+ super.initNativeView();
+
+ const that = new WeakRef(this);
+ const native = this.nativeViewProtected;
+
+ let usedAddListener = false;
+ try {
+ this._toggledHandler = new Windows.Foundation.TypedEventHandler((s) => {
+ const owner = that.deref();
+ if (!owner) return;
+ checkedProperty.nativeValueChange(owner, (s as any).isOn || (s as any).IsOn || false);
+ });
+
+ (native as any).Toggled = this._toggledHandler as never;
+ } catch (_e) {
+ this._toggledHandler = (s: any) => {
+ const owner = that.deref();
+ if (!owner) return;
+ checkedProperty.nativeValueChange(owner, (s as any).isOn || (s as any).IsOn || false);
+ };
+
+ try {
+ (native as any).Toggled = this._toggledHandler as never;
+ } catch (_e2) {
+ try {
+ if (typeof (native as any).addEventListener === 'function') {
+ (native as any).addEventListener('toggled', this._toggledHandler);
+ usedAddListener = true;
+ }
+ } catch (_e3) { }
+ }
+ }
+
+ this._toggledHandlerUsedAddListener = usedAddListener;
+ }
+
+ public disposeNativeView(): void {
+ const native = this.nativeViewProtected;
+ if (native && this._toggledHandler) {
+ try { (native as any).Toggled = null as never; } catch (_e) { }
+ if (this._toggledHandlerUsedAddListener) {
+ try { (native as any).removeEventListener('toggled', this._toggledHandler); } catch (_e) { }
+ }
+ this._toggledHandler = null;
+ this._toggledHandlerUsedAddListener = false;
+ }
+
+ super.disposeNativeView();
+ }
+
+ [checkedProperty.getDefault](): boolean {
+ return false;
+ }
+ [checkedProperty.setNative](value: boolean) {
+ if (this.nativeViewProtected) {
+ (this.nativeViewProtected as any).IsOn = !!value;
+ }
+ }
+
+ [colorProperty.setNative](value: number | Color) {
+ if (!this.nativeViewProtected) return;
+ const resources = this.nativeViewProtected.Resources;
+
+ if (value instanceof Color) {
+ const color = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never;
+ resources.Insert('ToggleSwitchKnobFillOn', color);
+ resources.Insert('ToggleSwitchKnobFillOff', color);
+ } else {
+ resources.Remove('ToggleSwitchKnobFillOn');
+ resources.Remove('ToggleSwitchKnobFillOff');
+ }
+ }
+
+ [backgroundColorProperty.setNative](value: number | Color) {
+ if (!this.nativeViewProtected) return;
+ if (!this.offBackgroundColor || this.checked) {
+ const resources = this.nativeViewProtected.Resources;
+ if (value instanceof Color) {
+ resources.Insert('ToggleSwitchFillOn', new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never);
+ } else {
+ resources.Remove('ToggleSwitchFillOn');
+ }
+ }
+ }
+
+ [backgroundInternalProperty.setNative](_value: any) {
+ // No-op for now
+ }
+
+ [offBackgroundColorProperty.setNative](value: number | Color) {
+ if (!this.nativeViewProtected) return;
+ if (!this.checked) {
+ const resources = this.nativeViewProtected.Resources;
+ if (value instanceof Color) {
+ resources.Insert('ToggleSwitchFillOff', new Windows.UI.Xaml.Media.SolidColorBrush(value.windows) as never);
+ } else {
+ resources.Remove('ToggleSwitchFillOff');
+ }
+ }
+ }
+}
diff --git a/packages/core/ui/tab-view/index.windows.ts b/packages/core/ui/tab-view/index.windows.ts
new file mode 100644
index 0000000000..432ae56e51
--- /dev/null
+++ b/packages/core/ui/tab-view/index.windows.ts
@@ -0,0 +1,187 @@
+export * from './tab-view-common';
+
+import { TabViewBase, TabViewItemBase } from './tab-view-common';
+
+const TAB_HEIGHT = 48;
+
+export class TabViewItem extends TabViewItemBase {
+ public _update(): void {
+ const parent = this.parent as TabView;
+ if (!parent) return;
+ parent._updateTabButton(this as any);
+ }
+}
+
+export class TabView extends TabViewBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.Grid;
+
+ private _outerGrid: Windows.UI.Xaml.Controls.Grid;
+ private _tabStrip: Windows.UI.Xaml.Controls.StackPanel;
+ private _contentArea: Windows.UI.Xaml.Controls.Grid;
+ private _tabButtons: Windows.UI.Xaml.Controls.Button[] = [];
+
+ constructor() {
+ super();
+
+ this._outerGrid = new Windows.UI.Xaml.Controls.Grid();
+
+ const r0 = new Windows.UI.Xaml.Controls.RowDefinition();
+ r0.Height = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.Auto);
+ const r1 = new Windows.UI.Xaml.Controls.RowDefinition();
+ r1.Height = new Windows.UI.Xaml.GridLength(1, Windows.UI.Xaml.GridUnitType.Star);
+ this._outerGrid.RowDefinitions.Append(r0);
+ this._outerGrid.RowDefinitions.Append(r1);
+
+ this._tabStrip = new Windows.UI.Xaml.Controls.StackPanel();
+ this._tabStrip.Orientation = Windows.UI.Xaml.Controls.Orientation.Horizontal;
+ Windows.UI.Xaml.Controls.Grid.SetRow(this._tabStrip, 0);
+ this._outerGrid.Children.Append(this._tabStrip);
+
+ this._contentArea = new Windows.UI.Xaml.Controls.Grid();
+ Windows.UI.Xaml.Controls.Grid.SetRow(this._contentArea, 1);
+ this._outerGrid.Children.Append(this._contentArea);
+ }
+
+ public createNativeView() {
+ return this._outerGrid;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.Grid {
+ return this._outerGrid;
+ }
+
+
+ public _addChildFromBuilder(name: string, value: any): void {
+ if (value instanceof TabViewItemBase) {
+ (value as any).canBeLoaded = true;
+ }
+ super._addChildFromBuilder(name, value);
+ if (value instanceof TabViewItemBase) {
+ this._rebuildTabStrip();
+ }
+ }
+
+ //
+ public onItemsChanged(oldItems: any[], newItems: any[]): void {
+ this._clearTabButtons();
+ this._tabStrip.Children.Clear();
+ this._clearContent();
+
+ if (newItems) {
+ for (const item of newItems) {
+ (item as any).canBeLoaded = true;
+ }
+ }
+
+ super.onItemsChanged(oldItems, newItems);
+
+ if (!newItems) return;
+
+ this._rebuildTabStrip();
+
+ if (this.isLoaded) {
+ this._showContent(Math.max(0, this.selectedIndex ?? 0));
+ }
+ }
+
+ public onLoaded(): void {
+ super.onLoaded();
+ this._clearContent();
+ const idx = Math.max(0, this.selectedIndex ?? 0);
+ this._showContent(idx);
+ this._highlightTab(idx);
+ }
+
+ public onSelectedIndexChanged(oldIndex: number, newIndex: number): void {
+ super.onSelectedIndexChanged(oldIndex, newIndex);
+ this._clearContent();
+ this._showContent(newIndex);
+ this._highlightTab(newIndex);
+ }
+
+ public disposeNativeView(): void {
+ this._clearTabButtons();
+ super.disposeNativeView();
+ }
+
+ public _updateTabButton(item: TabViewItemBase): void {
+ if (!this.items) return;
+ const idx = this.items.indexOf(item as any);
+ if (idx >= 0 && idx < this._tabButtons.length) {
+ try { (this._tabButtons[idx] as any).Content = item.title ?? ''; } catch (_e) { }
+ }
+ }
+
+ private _rebuildTabStrip(): void {
+ this._clearTabButtons();
+ this._tabStrip.Children.Clear();
+ const items = this.items;
+ if (!items) return;
+ for (let i = 0; i < items.length; i++) {
+ this._createTabButton(items[i], i);
+ }
+ this._highlightTab(Math.max(0, this.selectedIndex ?? 0));
+ }
+
+ private _createTabButton(item: any, index: number): void {
+ try {
+ const btn = new Windows.UI.Xaml.Controls.Button();
+ btn.Content = item.title ?? '';
+ btn.MinWidth = 80;
+ btn.Height = TAB_HEIGHT;
+
+ const that = new WeakRef(this);
+ const fn = () => {
+ const owner = that.deref();
+ if (owner) owner.selectedIndex = index;
+ };
+ let handler: any;
+ try {
+ handler = new Windows.UI.Xaml.RoutedEventHandler(fn);
+ } catch (_e) {
+ handler = fn;
+ }
+ try { btn.Click = handler as never; } catch (_e) { }
+
+ this._tabButtons[index] = btn;
+ this._tabStrip.Children.Append(btn);
+ } catch (_e) { }
+ }
+
+ private _clearTabButtons(): void {
+ for (const btn of this._tabButtons) {
+ try { if (btn) btn.Click = null as never; } catch (_e) { }
+ }
+ this._tabButtons = [];
+ }
+
+ private _clearContent(): void {
+ try {
+ const count = (this._contentArea as any).Children.Size;
+ for (let i = count - 1; i >= 0; i--) {
+ try { (this._contentArea as any).Children.RemoveAt(i); } catch (_e) { }
+ }
+ } catch (_e) { }
+ }
+
+ private _showContent(index: number): void {
+ const items = this.items;
+ if (!items || index < 0 || index >= items.length) return;
+ const native = (items[index] as any)?.view?.nativeViewProtected;
+ if (native) {
+ try { (this._contentArea as any).Children.Append(native); } catch (_e) { }
+ }
+ }
+
+ private _highlightTab(selectedIndex: number): void {
+ for (let i = 0; i < this._tabButtons.length; i++) {
+ const btn = this._tabButtons[i];
+ if (!btn) continue;
+ try {
+ (btn as any).FontWeight = i === selectedIndex
+ ? Windows.UI.Text.FontWeights.Bold
+ : Windows.UI.Text.FontWeights.Normal;
+ } catch (_e) { }
+ }
+ }
+}
diff --git a/packages/core/ui/text-base/index.windows.ts b/packages/core/ui/text-base/index.windows.ts
new file mode 100644
index 0000000000..50107d18cf
--- /dev/null
+++ b/packages/core/ui/text-base/index.windows.ts
@@ -0,0 +1,303 @@
+export * from './text-base-common';
+
+import { TextBaseCommon, textProperty, formattedTextProperty, textTransformProperty, textAlignmentProperty, whiteSpaceProperty, resetSymbol } from './text-base-common';
+import { CoreTypes } from '../../core-types';
+import { Color } from '../../color';
+import { colorProperty, fontInternalProperty, fontSizeProperty, paddingLeftProperty, paddingTopProperty, paddingRightProperty, paddingBottomProperty, fontWeightProperty, fontStyleProperty } from '../styling/style-properties';
+import { FontWeightType } from '../styling/font-interfaces';
+import { layout } from '../../utils';
+
+// WinUI uses DIPs — do not multiply by density. Convert px→dip for 'px' unit values.
+function toDip(value: CoreTypes.LengthType, auto = 0): number {
+ if (typeof value === 'number') return value;
+ if (!value || typeof value === 'string') return auto;
+ const v = value as { value: number; unit: string };
+ if (v.unit === 'dip') return v.value;
+ if (v.unit === 'px') return v.value / (layout.getDisplayDensity?.() ?? 1);
+ return auto;
+}
+
+function makeThickness(options: { Left?: number; Top?: number; Right?: number; Bottom?: number }, def: Windows.UI.Xaml.Thickness): Windows.UI.Xaml.Thickness {
+ const { Left, Top, Right, Bottom } = options;
+ return Windows.UI.Xaml.ThicknessHelper.FromLengths(Left ?? def.Left, Top ?? def.Top, Right ?? def.Right, Bottom ?? def.Bottom);
+}
+
+function toFontWeight(value: FontWeightType): Windows.UI.Text.FontWeight | null {
+ switch (value) {
+ case '700':
+ case 'bold':
+ return Windows.UI.Text.FontWeights.Bold;
+ case '400':
+ case 'normal':
+ return Windows.UI.Text.FontWeights.Normal;
+ case '100': return Windows.UI.Text.FontWeights.Thin;
+ case '200': return Windows.UI.Text.FontWeights.ExtraLight;
+ case '300': return Windows.UI.Text.FontWeights.Light;
+ case '500': return Windows.UI.Text.FontWeights.Medium;
+ case '600': return Windows.UI.Text.FontWeights.SemiBold;
+ case '800': return Windows.UI.Text.FontWeights.ExtraBold;
+ case '900': return Windows.UI.Text.FontWeights.Black;
+ default:
+ return null;
+ }
+}
+
+function fromFontWeight(value: Windows.UI.Text.FontWeight): FontWeightType {
+ switch (value) {
+ case Windows.UI.Text.FontWeights.Bold:
+ return '700';
+ case Windows.UI.Text.FontWeights.Normal:
+ return '400';
+ case Windows.UI.Text.FontWeights.Thin:
+ return '100';
+ case Windows.UI.Text.FontWeights.ExtraLight:
+ return '200';
+ case Windows.UI.Text.FontWeights.Light:
+ return '300';
+ case Windows.UI.Text.FontWeights.Medium:
+ return '500';
+ case Windows.UI.Text.FontWeights.SemiBold:
+ return '600';
+ case Windows.UI.Text.FontWeights.ExtraBold:
+ return '800';
+ case Windows.UI.Text.FontWeights.Black:
+ return '900';
+ default:
+ return '400';
+ }
+}
+
+function toFontStyle(value: 'normal' | 'italic' | 'oblique'): Windows.UI.Text.FontStyle | null {
+ switch (value) {
+ case 'italic':
+ return Windows.UI.Text.FontStyle.Italic;
+ case 'normal':
+ return Windows.UI.Text.FontStyle.Normal;
+ case 'oblique':
+ return Windows.UI.Text.FontStyle.Oblique;
+ default:
+ return null;
+ }
+}
+
+function fromFontStyle(value: Windows.UI.Text.FontStyle): 'normal' | 'italic' | 'oblique' | null {
+ if (value === Windows.UI.Text.FontStyle.Italic) {
+ return 'italic';
+ } else if (value === Windows.UI.Text.FontStyle.Oblique) {
+ return 'oblique';
+ } else if (value === Windows.UI.Text.FontStyle.Normal) {
+ return 'normal';
+ } else {
+ return 'normal';
+ }
+}
+
+
+export class TextBase extends TextBaseCommon {
+ nativeViewProtected: Windows.UI.Xaml.Controls.TextBox | Windows.UI.Xaml.Controls.TextBlock | Windows.UI.Xaml.Controls.PasswordBox | Windows.UI.Xaml.Controls.Button;
+
+ [textProperty.getDefault](): symbol {
+ return resetSymbol;
+ }
+
+ [textProperty.setNative](value: string | symbol): void {
+ const reset = value === resetSymbol;
+ if (!reset && this.formattedText) {
+ return;
+ }
+ this._setNativeText(reset);
+ }
+
+ [colorProperty.getDefault](): Windows.UI.Xaml.Media.Brush | null {
+ const nativeView = this.nativeTextViewProtected;
+ return nativeView?.Foreground ?? null;
+ }
+
+ [colorProperty.setNative](value: Color | Windows.UI.Color | null | undefined) {
+ if (!this.formattedText || !(value instanceof Color)) {
+ try {
+ let brush: Windows.UI.Xaml.Media.SolidColorBrush | null = null;
+ if (value instanceof Color) {
+ brush = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows);
+ } else if (value != null) {
+ //@ts-ignore
+ if (value instanceof Windows.UI.Color) {
+ brush = new Windows.UI.Xaml.Media.SolidColorBrush(value as any);
+ } else {
+ brush = new Windows.UI.Xaml.Media.SolidColorBrush(new Color(value as never).windows);
+ }
+ }
+ if (brush) {
+ this.nativeTextViewProtected.Foreground = brush;
+ // Override ButtonForeground resource so the XAML template binding picks up
+ // our colour even when the Normal-state VSM animation replaces it.
+ try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForeground', brush); } catch (_re) {}
+ try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForegroundPointerOver', brush); } catch (_re) {}
+ try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForegroundPressed', brush); } catch (_re) {}
+ }
+ } catch (_e) { }
+ }
+ }
+
+ [fontSizeProperty.getDefault](): { nativeSize: number } {
+ return { nativeSize: this.nativeTextViewProtected.FontSize ?? 0 };
+ }
+
+ [fontSizeProperty.setNative](value: number | { nativeSize: number }) {
+ if (!this.formattedText || typeof value !== 'number') {
+ const size = typeof value === 'number' ? value : value.nativeSize;
+ this.nativeTextViewProtected.FontSize = size;
+ }
+ }
+
+ [fontStyleProperty.getDefault]() {
+ return fromFontStyle(this.nativeTextViewProtected.FontStyle ?? Windows.UI.Text.FontStyle.Normal);
+ }
+
+ [fontStyleProperty.setNative](value: 'normal' | 'italic' | 'oblique') {
+ if (!this.formattedText) {
+ const style = toFontStyle(value);
+ if (!style) return;
+ this.nativeTextViewProtected.FontStyle = style;
+ }
+ }
+
+ [fontWeightProperty.getDefault](): FontWeightType {
+ return fromFontWeight(this.nativeTextViewProtected.FontWeight ?? Windows.UI.Text.FontWeights.Normal) as FontWeightType;
+ }
+
+ [fontWeightProperty.setNative](value: FontWeightType) {
+ const weight = toFontWeight(value);
+ if (!weight) return;
+ this.nativeTextViewProtected.FontWeight = weight;
+ }
+
+ [fontInternalProperty.setNative](value: any) {
+ const nativeView = this.nativeTextViewProtected as any;
+ if (!nativeView) return;
+
+ if (value) {
+ value?.applyWindowsFont?.(nativeView);
+
+ if (value?.fontStyle) {
+ const style = toFontStyle(value.fontStyle);
+ if (style) {
+ nativeView.FontStyle = style;
+ }
+ }
+ if (value?.fontWeight) {
+ const weight = toFontWeight(value.fontWeight);
+ if (weight) {
+ nativeView.FontWeight = weight;
+ }
+ }
+
+ if (value?.fontSize) {
+ nativeView.FontSize = value.fontSize;
+ }
+
+ }
+ }
+
+ [formattedTextProperty.setNative](value: any): void {
+ this._setNativeText();
+ textProperty.nativeValueChange(this, !value ? '' : value.toString());
+ }
+
+ [textTransformProperty.setNative](_value: CoreTypes.TextTransformType): void {
+ this._setNativeText();
+ }
+
+ [paddingTopProperty.getDefault](): CoreTypes.LengthType {
+ return { value: this._defaultPaddingTop, unit: 'px' };
+ }
+ [paddingTopProperty.setNative](value: CoreTypes.LengthType) {
+ const padding = this.nativeTextViewProtected.Padding;
+ if (!padding) return;
+ this.nativeTextViewProtected.Padding = makeThickness({
+ Top: toDip(value) + toDip(this.style.borderTopWidth),
+ }, padding);
+ }
+
+ [paddingRightProperty.getDefault](): CoreTypes.LengthType {
+ return { value: this._defaultPaddingRight, unit: 'px' };
+ }
+ [paddingRightProperty.setNative](value: CoreTypes.LengthType) {
+ const padding = this.nativeTextViewProtected.Padding;
+ if (!padding) return;
+ this.nativeTextViewProtected.Padding = makeThickness({
+ Right: toDip(value) + toDip(this.style.borderRightWidth),
+ }, padding);
+ }
+
+ [paddingBottomProperty.getDefault](): CoreTypes.LengthType {
+ return { value: this._defaultPaddingBottom, unit: 'px' };
+ }
+ [paddingBottomProperty.setNative](value: CoreTypes.LengthType) {
+ const padding = this.nativeTextViewProtected.Padding;
+ if (!padding) return;
+ this.nativeTextViewProtected.Padding = makeThickness({
+ Bottom: toDip(value) + toDip(this.style.borderBottomWidth),
+ }, padding);
+ }
+
+ [paddingLeftProperty.getDefault](): CoreTypes.LengthType {
+ return { value: this._defaultPaddingLeft, unit: 'px' };
+ }
+ [paddingLeftProperty.setNative](value: CoreTypes.LengthType) {
+ const padding = this.nativeTextViewProtected.Padding;
+ if (!padding) return;
+ this.nativeTextViewProtected.Padding = makeThickness({
+ Left: toDip(value) + toDip(this.style.borderLeftWidth),
+ }, padding);
+ }
+
+ // TextAlignment: Left=0, Center=1, Right=2, Justify=3
+ [textAlignmentProperty.setNative](value: CoreTypes.TextAlignmentType) {
+ const nativeView = this.nativeTextViewProtected as any;
+ if (!nativeView) return;
+ switch (value) {
+ case 'left': nativeView.TextAlignment = 0; break;
+ case 'center': nativeView.TextAlignment = 1; break;
+ case 'right': nativeView.TextAlignment = 2; break;
+ case 'justify': nativeView.TextAlignment = 3; break;
+ }
+ }
+
+ // TextWrapping: NoWrap=1, Wrap=2, WrapWholeWords=3
+ [whiteSpaceProperty.setNative](value: CoreTypes.WhiteSpaceType) {
+ const nativeView = this.nativeTextViewProtected as any;
+ if (!nativeView) return;
+ nativeView.TextWrapping = (value === 'nowrap') ? 1 : 3; // NoWrap or WrapWholeWords
+ }
+
+
+ _setNativeText(reset = false): void {
+ const nativeView = this.nativeTextViewProtected as any;
+ if (!nativeView) return;
+
+ const text = reset ? '' : getTransformedText(this.text ?? '', this.textTransform);
+
+ if (typeof nativeView.Text !== 'undefined') {
+ nativeView.Text = text;
+ } else if (typeof nativeView.Content !== 'undefined') {
+ nativeView.Content = text;
+ }
+ }
+}
+
+export function getTransformedText(text: string, textTransform: CoreTypes.TextTransformType): string {
+ if (!text || !textTransform || textTransform === 'none') {
+ return text;
+ }
+ switch (textTransform) {
+ case 'uppercase':
+ return text.toUpperCase();
+ case 'lowercase':
+ return text.toLowerCase();
+ case 'capitalize':
+ return text.replace(/\b\w/g, (c) => c.toUpperCase());
+ default:
+ return text;
+ }
+}
diff --git a/packages/core/ui/text-field/index.windows.ts b/packages/core/ui/text-field/index.windows.ts
new file mode 100644
index 0000000000..43aa058882
--- /dev/null
+++ b/packages/core/ui/text-field/index.windows.ts
@@ -0,0 +1,120 @@
+export * from './text-field-common';
+
+import { TextFieldBase, secureProperty } from './text-field-common';
+import { hintProperty, editableProperty, maxLengthProperty, keyboardTypeProperty, autocapitalizationTypeProperty } from '../editable-text-base/editable-text-base-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import type { CoreTypes } from '../../core-types';
+
+const KEYBOARD_SCOPE: Record = {
+ number: 29,
+ datetime: 29,
+ phone: 3,
+ email: 7,
+ url: 14,
+ integer: 29,
+};
+
+function applyInputScope(nativeView: any, kbType: string): void {
+ try {
+ const scopeValue = KEYBOARD_SCOPE[kbType];
+ if (scopeValue === undefined) return;
+ const scope = new Windows.UI.Xaml.Input.InputScope();
+ const scopeName = new Windows.UI.Xaml.Input.InputScopeName();
+ (scopeName as any).NameValue = scopeValue;
+ ((scope as any).Names as Windows.Foundation.Collections.IVector).Append(scopeName);
+ nativeView.InputScope = scope;
+ } catch (_e) {}
+}
+
+export class TextField extends TextFieldBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.TextBox | Windows.UI.Xaml.Controls.PasswordBox;
+ private _isSecure = false;
+
+ public createNativeView(): any {
+ return this._isSecure
+ ? new Windows.UI.Xaml.Controls.PasswordBox()
+ : new Windows.UI.Xaml.Controls.TextBox();
+ }
+
+ [secureProperty.setNative](value: boolean) {
+ if (this._isSecure === !!value) return;
+ this._isSecure = !!value;
+
+ const prev = this.nativeViewProtected as any;
+ const currentText = this._isSecure ? (prev?.Password ?? '') : (prev?.Text ?? '');
+
+ try {
+ const newView: any = this._isSecure
+ ? new Windows.UI.Xaml.Controls.PasswordBox()
+ : new Windows.UI.Xaml.Controls.TextBox();
+
+ // Try to swap in parent visual tree
+ const nativeParent = (this.parent as any)?.nativeViewProtected;
+ if (nativeParent?.Children) {
+ const children: any = nativeParent.Children;
+ const count: number = children.Size;
+ for (let i = 0; i < count; i++) {
+ if (children.GetAt(i) === prev) {
+ children.RemoveAt(i);
+ children.Append(newView);
+ break;
+ }
+ }
+ }
+ this.nativeViewProtected = newView;
+ if (this._isSecure) {
+ newView.Password = currentText;
+ } else {
+ newView.Text = currentText;
+ }
+ } catch (_e) {}
+ }
+
+ [hintProperty.setNative](value: string) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.PlaceholderText !== 'undefined') {
+ nativeView.PlaceholderText = value ?? '';
+ }
+ }
+
+ [editableProperty.setNative](value: boolean) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.IsReadOnly !== 'undefined') {
+ nativeView.IsReadOnly = !value;
+ }
+ }
+
+ [maxLengthProperty.setNative](value: number) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.MaxLength !== 'undefined') {
+ nativeView.MaxLength = value ?? 0;
+ }
+ }
+
+ //@ts-ignore
+ [keyboardTypeProperty.setNative](value: CoreTypes.KeyboardInputType) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView) applyInputScope(nativeView, value);
+ }
+
+ //@ts-ignore
+ [autocapitalizationTypeProperty.setNative](value: CoreTypes.AutocapitalizationInputType) {
+ const nativeView = this.nativeViewProtected as any;
+ if (!nativeView) return;
+ try {
+ nativeView.CharacterCasing = value === 'allcharacters' ? 1 : 0;
+ } catch (_e) {}
+ }
+
+ //@ts-ignore
+ [colorProperty.setNative](value: Color | null) {
+ const nativeView = this.nativeViewProtected as any;
+ if (!nativeView) return;
+ try {
+ if (value instanceof Color) {
+ nativeView.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows);
+ }
+ } catch (_e) {}
+ }
+}
diff --git a/packages/core/ui/text-view/index.windows.ts b/packages/core/ui/text-view/index.windows.ts
new file mode 100644
index 0000000000..9a4908460f
--- /dev/null
+++ b/packages/core/ui/text-view/index.windows.ts
@@ -0,0 +1,75 @@
+export * from './text-view-common';
+
+import { TextViewBase } from './text-view-common';
+import { hintProperty, editableProperty, maxLengthProperty, keyboardTypeProperty } from '../editable-text-base/editable-text-base-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import type { CoreTypes } from '../../core-types';
+
+const KEYBOARD_SCOPE: Record = {
+ number: 29,
+ datetime: 29,
+ phone: 3,
+ email: 7,
+ url: 14,
+ integer: 29,
+};
+
+export class TextView extends TextViewBase {
+ declare nativeViewProtected: Windows.UI.Xaml.Controls.TextBox;
+
+ createNativeView(): any {
+ const textBox = new Windows.UI.Xaml.Controls.TextBox();
+ (textBox as any).AcceptsReturn = true;
+ (textBox as any).TextWrapping = 1; // Wrap
+ (textBox as any).VerticalScrollBarVisibility = 1; // Auto
+ return textBox;
+ }
+
+ [hintProperty.setNative](value: string) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.PlaceholderText !== 'undefined') {
+ nativeView.PlaceholderText = value ?? '';
+ }
+ }
+
+ [editableProperty.setNative](value: boolean) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.IsReadOnly !== 'undefined') {
+ nativeView.IsReadOnly = !value;
+ }
+ }
+
+ [maxLengthProperty.setNative](value: number) {
+ const nativeView = this.nativeViewProtected as any;
+ if (nativeView && typeof nativeView.MaxLength !== 'undefined') {
+ nativeView.MaxLength = value ?? 0;
+ }
+ }
+
+ //@ts-ignore
+ [keyboardTypeProperty.setNative](value: CoreTypes.KeyboardInputType) {
+ const nativeView = this.nativeViewProtected as any;
+ if (!nativeView) return;
+ try {
+ const scopeValue = KEYBOARD_SCOPE[value];
+ if (scopeValue === undefined) return;
+ const scope = new Windows.UI.Xaml.Input.InputScope();
+ const scopeName = new Windows.UI.Xaml.Input.InputScopeName();
+ (scopeName as any).NameValue = scopeValue;
+ ((scope as any).Names as Windows.Foundation.Collections.IVector).Append(scopeName);
+ nativeView.InputScope = scope;
+ } catch (_e) {}
+ }
+
+ //@ts-ignore
+ [colorProperty.setNative](value: Color | null) {
+ const nativeView = this.nativeViewProtected as any;
+ if (!nativeView) return;
+ try {
+ if (value instanceof Color) {
+ nativeView.Foreground = new Windows.UI.Xaml.Media.SolidColorBrush(value.windows);
+ }
+ } catch (_e) {}
+ }
+}
diff --git a/packages/core/ui/time-picker/index.windows.ts b/packages/core/ui/time-picker/index.windows.ts
new file mode 100644
index 0000000000..a779da5d6d
--- /dev/null
+++ b/packages/core/ui/time-picker/index.windows.ts
@@ -0,0 +1,21 @@
+export * from './time-picker-common';
+
+import { TimePickerBase } from './time-picker-common';
+
+export class TimePicker extends TimePickerBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.TimePicker;
+ private _windows: Windows.UI.Xaml.Controls.TimePicker;
+
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.TimePicker();
+ }
+
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.TimePicker {
+ return this._windows;
+ }
+}
diff --git a/packages/core/ui/transition/fade-transition.windows.ts b/packages/core/ui/transition/fade-transition.windows.ts
new file mode 100644
index 0000000000..41726706d6
--- /dev/null
+++ b/packages/core/ui/transition/fade-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class FadeTransition extends Transition {}
diff --git a/packages/core/ui/transition/index.windows.ts b/packages/core/ui/transition/index.windows.ts
new file mode 100644
index 0000000000..153ddb9ebf
--- /dev/null
+++ b/packages/core/ui/transition/index.windows.ts
@@ -0,0 +1,42 @@
+export * from './shared-transition';
+
+let transitionId = 0;
+
+export class Transition {
+ static AndroidTransitionType: { enter?: string; exit?: string; popEnter?: string; popExit?: string } = {};
+ id: number;
+ name?: string;
+ private _duration: number;
+ private _curve: any;
+
+ constructor(duration: number = 350, nativeCurve?: any) {
+ this._duration = duration ? duration / 1000 : 0.35;
+ this._curve = nativeCurve;
+ transitionId++;
+ this.id = transitionId;
+ }
+
+ getDuration(): number {
+ return this._duration;
+ }
+
+ setDuration(value: number): void {
+ this._duration = value;
+ }
+
+ getCurve(): any {
+ return this._curve;
+ }
+
+ animateIOSTransition(_transitionContext: any, _fromViewCtrl: any, _toViewCtrl: any, _operation: any): void {
+ throw new Error('Abstract method call');
+ }
+
+ createAndroidAnimator(_transitionType: string): any {
+ throw new Error('Abstract method call');
+ }
+
+ toString(): string {
+ return `Transition@${this.id}`;
+ }
+}
diff --git a/packages/core/ui/transition/modal-transition.windows.ts b/packages/core/ui/transition/modal-transition.windows.ts
new file mode 100644
index 0000000000..daf5025246
--- /dev/null
+++ b/packages/core/ui/transition/modal-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class ModalTransition extends Transition {}
diff --git a/packages/core/ui/transition/page-transition.windows.ts b/packages/core/ui/transition/page-transition.windows.ts
new file mode 100644
index 0000000000..b25e031ccb
--- /dev/null
+++ b/packages/core/ui/transition/page-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class PageTransition extends Transition {}
diff --git a/packages/core/ui/transition/shared-transition-helper.windows.ts b/packages/core/ui/transition/shared-transition-helper.windows.ts
new file mode 100644
index 0000000000..e7ba4783b1
--- /dev/null
+++ b/packages/core/ui/transition/shared-transition-helper.windows.ts
@@ -0,0 +1,14 @@
+import type { TransitionInteractiveState, TransitionNavigationType } from '.';
+import { SharedTransitionState } from './shared-transition';
+
+export class SharedTransitionHelper {
+ static animate(_state: SharedTransitionState, _transitionContext: any, _type: TransitionNavigationType): void {}
+
+ static interactiveStart(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void {}
+
+ static interactiveUpdate(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType, _percent: number): void {}
+
+ static interactiveCancel(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void {}
+
+ static interactiveFinish(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void {}
+}
diff --git a/packages/core/ui/transition/slide-transition.windows.ts b/packages/core/ui/transition/slide-transition.windows.ts
new file mode 100644
index 0000000000..477ef6e37a
--- /dev/null
+++ b/packages/core/ui/transition/slide-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class SlideTransition extends Transition {}
diff --git a/packages/core/ui/utils.windows.ts b/packages/core/ui/utils.windows.ts
new file mode 100644
index 0000000000..98cd160453
--- /dev/null
+++ b/packages/core/ui/utils.windows.ts
@@ -0,0 +1,17 @@
+export namespace ios {
+ export function getActualHeight(_view: any): number {
+ return 0;
+ }
+ export function getStatusBarHeight(_viewController?: any): number {
+ return 0;
+ }
+ export function _layoutRootView(_rootView: any, _parentBounds: any) {}
+}
+
+export namespace windows {
+ export function getActualHeight(_view: any): number {
+ return 0;
+ }
+}
+
+export type NativeScriptUIView = any;
diff --git a/packages/core/ui/web-view/index.windows.ts b/packages/core/ui/web-view/index.windows.ts
new file mode 100644
index 0000000000..8382b67e5f
--- /dev/null
+++ b/packages/core/ui/web-view/index.windows.ts
@@ -0,0 +1,49 @@
+export * from './web-view-common';
+
+import { WebViewBase } from './web-view-common';
+
+export class WebView extends WebViewBase {
+ nativeViewProtected: Windows.UI.Xaml.Controls.WebView;
+ private _windows: Windows.UI.Xaml.Controls.WebView;
+ constructor() {
+ super();
+ this._windows = new Windows.UI.Xaml.Controls.WebView();
+ }
+ public createNativeView() {
+ return this._windows;
+ }
+
+ get windows(): Windows.UI.Xaml.Controls.WebView {
+ return this._windows;
+ }
+
+ public _loadUrl(src: string): void {
+ console.log('Loading URL in WebView for Windows is not implemented yet.', src); // TODO: Implement loading URL in WebView for Windows
+ this.nativeViewProtected.Navigate(new Windows.Foundation.Uri(src));
+ }
+
+ public _loadData(src: string): void {
+ console.log('Loading data in WebView for Windows is not implemented yet.', src); // TODO: Implement loading data in WebView for Windows
+ this.nativeViewProtected.NavigateToString(src);
+ }
+
+ public stopLoading(): void {
+ this.nativeViewProtected.Stop();
+ }
+
+ get canGoBack(): boolean {
+ return this.nativeViewProtected.CanGoBack;
+ }
+ get canGoForward(): boolean {
+ return this.nativeViewProtected.CanGoForward;
+ }
+ goBack(): void {
+ this.nativeViewProtected.GoBack();
+ }
+ goForward(): void {
+ this.nativeViewProtected.GoForward();
+ }
+ reload(): void {
+ this.nativeViewProtected.Refresh();
+ }
+}
diff --git a/packages/core/utils/constants.windows.ts b/packages/core/utils/constants.windows.ts
new file mode 100644
index 0000000000..ccb814e1c6
--- /dev/null
+++ b/packages/core/utils/constants.windows.ts
@@ -0,0 +1,5 @@
+export const SDK_VERSION = 0;
+
+export function supportsGlass(): boolean {
+ return false;
+}
diff --git a/packages/core/utils/debug-source.ts b/packages/core/utils/debug-source.ts
index 6ae704ee7f..a57b570d45 100644
--- a/packages/core/utils/debug-source.ts
+++ b/packages/core/utils/debug-source.ts
@@ -15,6 +15,8 @@ function getCurrentAppPath(): string {
}
return appPath;
+ } else if (__WINDOWS__) {
+ return global.__dirname || '';
} else {
const dir = getNativeApp().getApplicationContext().getFilesDir();
diff --git a/packages/core/utils/index.windows.ts b/packages/core/utils/index.windows.ts
new file mode 100644
index 0000000000..25423f5565
--- /dev/null
+++ b/packages/core/utils/index.windows.ts
@@ -0,0 +1,104 @@
+import { Trace } from '../trace';
+import { debounce, throttle } from './shared';
+
+export { clearInterval, clearTimeout, setInterval, setTimeout } from '../timer';
+export * from './animation-helpers';
+export * from './common';
+export * from './constants';
+export * from './debug';
+export * from './layout-helper';
+export * from './macrotask-scheduler';
+export * from './mainthread-helper';
+export * from './native-helper';
+export * from './shared';
+export * from './types';
+
+export function GC() {
+ if (typeof gc === 'function') {
+ (gc as any)();
+ }
+}
+
+let throttledGC: Map void>;
+let debouncedGC: Map void>;
+
+export function queueGC(delay = 900, useThrottle?: boolean) {
+ if (useThrottle) {
+ if (!throttledGC) {
+ throttledGC = new Map();
+ }
+ if (!throttledGC.get(delay)) {
+ throttledGC.set(
+ delay,
+ throttle(() => GC(), delay),
+ );
+ }
+ throttledGC.get(delay)();
+ } else {
+ if (!debouncedGC) {
+ debouncedGC = new Map();
+ }
+ if (!debouncedGC.get(delay)) {
+ debouncedGC.set(
+ delay,
+ debounce(() => GC(), delay),
+ );
+ }
+ debouncedGC.get(delay)();
+ }
+}
+
+export function releaseNativeObject(_object: any): void {}
+
+export function openUrl(location: string): boolean {
+ try {
+ Windows.System.Launcher.LaunchUriAsync(new Windows.Foundation.Uri(location.trim()));
+ return true;
+ } catch (e) {
+ Trace.write(`Failed to open URL: ${location}`, Trace.categories.Error, Trace.messageType.error);
+ return false;
+ }
+}
+
+export function openUrlAsync(location: string): Promise {
+ return new Promise((resolve) => {
+ try {
+ Windows.System.Launcher.LaunchUriAsync(new Windows.Foundation.Uri(location.trim())).then((result: boolean) => resolve(result));
+ } catch (e) {
+ Trace.write(`Failed to open URL: ${location}`, Trace.categories.Error, Trace.messageType.error);
+ resolve(false);
+ }
+ });
+}
+
+export function openFile(filePath: string, _title: string = 'Open File...'): boolean {
+ try {
+ Windows.System.StorageFile.GetFileFromPathAsync(filePath).then((file: any) => {
+ Windows.System.Launcher.LaunchFileAsync(file);
+ });
+ return true;
+ } catch (e) {
+ Trace.write(`Error in openFile: ${e.message}`, Trace.categories.Error, Trace.messageType.error);
+ return false;
+ }
+}
+
+export function dismissSoftInput(_nativeView?: any): void {
+ try {
+ Windows.UI.ViewManagement.InputPane.GetForCurrentView()?.TryHide();
+ } catch {}
+}
+
+export function dismissKeyboard(): void {
+ dismissSoftInput();
+}
+
+export function copyToClipboard(value: string): void {
+ try {
+ const dataPackage = new Windows.ApplicationModel.DataTransfer.DataPackage();
+ dataPackage.SetText(value);
+ Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(dataPackage);
+ } catch (err) {
+ console.log(err);
+ }
+}
diff --git a/packages/core/utils/layout-helper/index.windows.ts b/packages/core/utils/layout-helper/index.windows.ts
new file mode 100644
index 0000000000..7ce58baabb
--- /dev/null
+++ b/packages/core/utils/layout-helper/index.windows.ts
@@ -0,0 +1,82 @@
+import * as layoutCommon from './layout-helper-common';
+
+export namespace layout {
+ export const MODE_SHIFT = 30;
+ export const MODE_MASK = 0x3 << MODE_SHIFT;
+
+ export const UNSPECIFIED = 0 << MODE_SHIFT;
+ export const EXACTLY = 1 << MODE_SHIFT;
+ export const AT_MOST = 2 << MODE_SHIFT;
+
+ export const MEASURED_HEIGHT_STATE_SHIFT = 0x00000010;
+ export const MEASURED_STATE_TOO_SMALL = 0x01000000;
+ export const MEASURED_STATE_MASK = 0xff000000;
+ export const MEASURED_SIZE_MASK = 0x00ffffff;
+
+ export function getMode(mode: number) {
+ return layoutCommon.getMode(mode);
+ }
+
+ export function getMeasureSpecMode(spec: number): number {
+ return layoutCommon.getMeasureSpecMode(spec);
+ }
+
+ export function getMeasureSpecSize(spec: number) {
+ return layoutCommon.getMeasureSpecSize(spec);
+ }
+
+ export function makeMeasureSpec(size: number, mode: number): number {
+ return (Math.round(Math.max(0, size)) & ~MODE_MASK) | (mode & MODE_MASK);
+ }
+
+ export function hasRtlSupport(): boolean {
+ return true;
+ }
+
+ export function getDisplayDensity(): number {
+ try {
+ return Windows.Graphics.Display.DisplayInformation.GetForCurrentView().RawPixelsPerViewPixel || 1;
+ } catch {
+ return 1;
+ }
+ }
+
+ export function toDevicePixels(value: number): number {
+ return value * getDisplayDensity();
+ }
+
+ export function toDeviceIndependentPixels(value: number): number {
+ return value / getDisplayDensity();
+ }
+
+ export function round(value: number) {
+ return layoutCommon.round(value);
+ }
+
+ export function measureNativeView(nativeView: any, width: number, widthMode: number, height: number, heightMode: number): { width: number; height: number } {
+
+ if (nativeView && nativeView.Measure) {
+ const size = new Windows.Foundation.Size(
+ widthMode === 0 /* layout.UNSPECIFIED */ ? Number.NaN : toDeviceIndependentPixels(width),
+ heightMode === 0 /* layout.UNSPECIFIED */ ? Number.NaN : toDeviceIndependentPixels(height),
+ );
+
+ (nativeView as Windows.UI.Xaml.FrameworkElement).Measure(size);
+
+
+ const ret = (nativeView as Windows.UI.Xaml.FrameworkElement).DesiredSize;
+
+ return {
+ width: round(toDevicePixels(ret.Width)),
+ height: round(toDevicePixels(ret.Height)),
+ };
+
+ }
+
+ return { width: 0, height: 0 };
+ }
+
+ export function measureSpecToString(measureSpec: number) {
+ return layoutCommon.measureSpecToString(measureSpec);
+ }
+}
diff --git a/packages/core/utils/mainthread-helper.windows.ts b/packages/core/utils/mainthread-helper.windows.ts
new file mode 100644
index 0000000000..598e9ec71c
--- /dev/null
+++ b/packages/core/utils/mainthread-helper.windows.ts
@@ -0,0 +1,18 @@
+export function dispatchToMainThread(func: () => void): void {
+ (global as any).__nsRunOnUIThread(() => {
+ func();
+ })
+}
+
+export function isMainThread(): boolean {
+ try {
+ const dispatcher = Windows?.UI?.Core?.CoreWindow?.GetForCurrentThread?.()?.Dispatcher;
+ return dispatcher ? dispatcher.HasThreadAccess : true;
+ } catch {
+ return true;
+ }
+}
+
+export function dispatchToUIThread(func: () => void): void {
+ dispatchToMainThread(func);
+}
diff --git a/packages/core/utils/native-helper.windows.ts b/packages/core/utils/native-helper.windows.ts
new file mode 100644
index 0000000000..5c437ed365
--- /dev/null
+++ b/packages/core/utils/native-helper.windows.ts
@@ -0,0 +1,124 @@
+import { platformCheck } from './platform-check';
+
+export function dataSerialize(data: any): any {
+ return data;
+}
+
+
+function tryDeserializeJsonValue(value: any): any {
+ if (value === null || value === undefined) return value;
+
+ //@ts-ignore
+ const JsonValueType = Windows.Data.Json.JsonValueType;
+
+ try {
+ switch (value.ValueType) {
+ case JsonValueType.Null:
+ return null;
+ case JsonValueType.Boolean:
+ return value.GetBoolean();
+ case JsonValueType.Number:
+ return value.GetNumber();
+ case JsonValueType.String:
+ return value.GetString();
+ case JsonValueType.Array:
+ return dataDeserialize(value.GetArray());
+ case JsonValueType.Object:
+ return dataDeserialize(value.GetObject());
+ default:
+ return value;
+ }
+ } catch {
+ try {
+ return JSON.parse(value.Stringify());
+ } catch {
+ return value;
+ }
+ }
+}
+
+export function dataDeserialize(data: any): any {
+ if (data === null || typeof data !== 'object') {
+ return data;
+ }
+
+
+ if (data instanceof Windows.Data.Json.JsonObject) {
+ const obj: Record = {};
+ const iterator = data.First();
+ try {
+ while (iterator.HasCurrent) {
+ const current = iterator.Current;
+
+ obj[current.Key] = tryDeserializeJsonValue(current.Value)
+ iterator.MoveNext();
+ }
+ } catch { }
+ return obj;
+ }
+
+ if (data instanceof Windows.Data.Json.JsonArray) {
+ const result: any[] = [];
+ for (let i = 0; i < data.Size; i++) {
+ result.push(tryDeserializeJsonValue(data.GetObjectAt(i) ?? data.GetAt(i)));
+ }
+ return result;
+ }
+
+ //@ts-ignore
+ if (data instanceof Windows.Data.Json.JsonValue) {
+ return tryDeserializeJsonValue(data);
+ }
+
+
+
+ if (
+ //@ts-ignore
+ data instanceof Windows.Foundation.Collections.IVector ||
+ //@ts-ignore
+ data instanceof Windows.Foundation.Collections.IVectorView
+ ) {
+ const result = [];
+
+ for (let i = 0; i < data.Size; i++) {
+ result.push(dataDeserialize(data.GetAt(i)));
+ }
+
+ return result;
+ }
+
+
+ if (
+ //@ts-ignore
+ data instanceof Windows.Foundation.Collections.IMap ||
+ //@ts-ignore
+ data instanceof Windows.Foundation.Collections.IMapView
+ ) {
+ const obj: Record = {};
+
+ const iterator = data.First();
+
+ while (iterator.HasCurrent) {
+ const current = iterator.Current;
+
+ obj[current.Key] = dataDeserialize(current.Value);
+
+ iterator.MoveNext();
+ }
+
+ return obj;
+ }
+ return data;
+}
+
+export function isRealDevice(): boolean {
+ return true;
+}
+
+export const windows = {};
+
+// These don't exist on Windows — stub them to warn in dev.
+export const ad = platformCheck('Utils.ad');
+export const android = platformCheck('Utils.android');
+export const ios = platformCheck('Utils.ios');
+export const iOSNativeHelper = platformCheck('Utils.iOSNativeHelper');
diff --git a/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts b/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts
new file mode 100644
index 0000000000..2f7529d27d
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts
@@ -0,0 +1,59 @@
+// Auto-generated by typings-generator (dotnet mode).
+
+ namespace NativeScript.Widgets {
+ class ImageResult {
+ readonly Bitmap: Windows.UI.Xaml.Media.Imaging.BitmapImage;
+ readonly RawBuffer: Windows.Storage.Streams.IBuffer;
+ readonly Width: number;
+ readonly Height: number;
+ }
+
+ class ImageHelper {
+ static LoadFromBufferAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation;
+ static LoadFromUrlAsync(url: string): Windows.Foundation.IAsyncOperation;
+ static LoadFromFileAsync(path: string): Windows.Foundation.IAsyncOperation;
+ static ResizeAsync(buffer: Windows.Storage.Streams.IBuffer, maxSize: number): Windows.Foundation.IAsyncOperation;
+ static SaveToFileAsync(buffer: Windows.Storage.Streams.IBuffer, path: string): Windows.Foundation.IAsyncOperation;
+ static ReadFileAsync(path: string): Windows.Foundation.IAsyncOperation;
+ static BufferToBase64(buffer: Windows.Storage.Streams.IBuffer): string;
+ }
+
+ class CompositionBorderHelper {
+ static Create(element: Windows.UI.Xaml.UIElement): CompositionBorderHelper | null;
+ UpdateBorderWidth(left: number, top: number, right: number, bottom: number): void;
+ UpdateBorderColor(left: number, top: number, right: number, bottom: number): void;
+ UpdateBorderRadius(tl: number, tr: number, br: number, bl: number): void;
+ Free(): void;
+ }
+
+ class FlexboxLayout extends Windows.UI.Xaml.Controls.Panel {
+ static readonly FlexDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly FlexWrapProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly JustifyContentProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly AlignItemsProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly AlignContentProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly OrderProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly FlexGrowProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly FlexShrinkProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly AlignSelfProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly FlexBasisPercentProperty: Windows.UI.Xaml.DependencyProperty;
+ static readonly WrapBeforeProperty: Windows.UI.Xaml.DependencyProperty;
+ FlexDirection: number;
+ FlexWrap: number;
+ JustifyContent: number;
+ AlignItems: number;
+ AlignContent: number;
+ static GetOrder(e: Windows.UI.Xaml.UIElement): number;
+ static SetOrder(e: Windows.UI.Xaml.UIElement, v: number): void;
+ static GetFlexGrow(e: Windows.UI.Xaml.UIElement): number;
+ static SetFlexGrow(e: Windows.UI.Xaml.UIElement, v: number): void;
+ static GetFlexShrink(e: Windows.UI.Xaml.UIElement): number;
+ static SetFlexShrink(e: Windows.UI.Xaml.UIElement, v: number): void;
+ static GetAlignSelf(e: Windows.UI.Xaml.UIElement): number;
+ static SetAlignSelf(e: Windows.UI.Xaml.UIElement, v: number): void;
+ static GetFlexBasisPercent(e: Windows.UI.Xaml.UIElement): number;
+ static SetFlexBasisPercent(e: Windows.UI.Xaml.UIElement, v: number): void;
+ static GetWrapBefore(e: Windows.UI.Xaml.UIElement): boolean;
+ static SetWrapBefore(e: Windows.UI.Xaml.UIElement, v: boolean): void;
+ }
+ }
diff --git a/packages/types-minimal/src/lib/windows/windows.d.ts b/packages/types-minimal/src/lib/windows/windows.d.ts
new file mode 100644
index 0000000000..e528783ef6
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/windows.d.ts
@@ -0,0 +1,151133 @@
+// Auto-generated by typings-generator
+// Experimental: incomplete WinRT projection coverage
+
+/** Projected WinRT GUID value struct. toString()/valueOf() return the standard
+ * {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} string form. */
+interface Guid {
+ /** High 32 bits */
+ data1: number;
+ /** Bits 32-47 */
+ data2: number;
+ /** Bits 48-63 */
+ data3: number;
+ /** Low 64 bits as 8 individual bytes */
+ data4: number[];
+ toString(): string;
+ valueOf(): string;
+}
+
+// Roots: Windows
+
+declare namespace Windows.AI.Actions {
+ class ActionEntity implements Windows.AI.Actions.IActionEntity, Windows.AI.Actions.IActionEntity2, Windows.Foundation.IClosable {
+ Close(): void;
+ readonly DisplayInfo: Windows.AI.Actions.ActionEntityDisplayInfo;
+ readonly Id: string;
+ readonly Kind: number;
+ }
+
+ class ActionEntityDisplayInfo implements Windows.AI.Actions.IActionEntityDisplayInfo, Windows.Foundation.IClosable {
+ Close(): void;
+ readonly Title: string;
+ }
+
+ class ActionEntityFactory implements Windows.AI.Actions.IActionEntityFactory2, Windows.AI.Actions.IActionEntityFactory3, Windows.AI.Actions.IActionEntityFactory4, Windows.Foundation.IClosable {
+ Close(): void;
+ CreateContactEntity(contact: Windows.ApplicationModel.Contacts.Contact): Windows.AI.Actions.ContactActionEntity;
+ CreateDocumentEntity(path: string): Windows.AI.Actions.DocumentActionEntity;
+ CreateFileEntity(path: string): Windows.AI.Actions.FileActionEntity;
+ CreatePhotoEntity(path: string): Windows.AI.Actions.PhotoActionEntity;
+ CreateRemoteFileEntity(sourceId: string, fileKind: number, sourceUri: Windows.Foundation.Uri, fileId: string, contentType: string, driveId: string, accountId: string, extension: string): Windows.AI.Actions.RemoteFileActionEntity;
+ CreateStreamingTextActionEntityWriter(textFormat: number): Windows.AI.Actions.StreamingTextActionEntityWriter;
+ CreateTableEntity(data: string[], columnCount: number): Windows.AI.Actions.TableActionEntity;
+ CreateTextEntity(text: string): Windows.AI.Actions.TextActionEntity;
+ CreateTextEntity(text: string, textFormat: number): Windows.AI.Actions.TextActionEntity;
+ }
+
+ class ActionFeedback implements Windows.AI.Actions.IActionFeedback, Windows.Foundation.IClosable {
+ Close(): void;
+ readonly FeedbackKind: number;
+ }
+
+ class ActionInvocationContext implements Windows.AI.Actions.IActionInvocationContext, Windows.AI.Actions.IActionInvocationContext2, Windows.Foundation.IClosable {
+ Close(): void;
+ GetInputEntities(): Windows.AI.Actions.NamedActionEntity[];
+ GetOutputEntities(): Windows.AI.Actions.NamedActionEntity[];
+ SetInputEntity(inputName: string, inputValue: Windows.AI.Actions.ActionEntity): void;
+ SetOutputEntity(outputName: string, outputValue: Windows.AI.Actions.ActionEntity): void;
+ readonly ActionId: string;
+ readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+ ExtendedError: Windows.Foundation.HResult;
+ readonly HelpDetails: Windows.AI.Actions.ActionInvocationHelpDetails;
+ readonly InvokerAppUserModelId: string;
+ readonly InvokerWindowId: Windows.UI.WindowId;
+ Result: number;
+ }
+
+ class ActionInvocationHelpDetails implements Windows.AI.Actions.IActionInvocationHelpDetails, Windows.Foundation.IClosable {
+ Close(): void;
+ Description: string;
+ HelpUri: Windows.Foundation.Uri;
+ HelpUriDescription: string;
+ Kind: number;
+ Title: string;
+ }
+
+ class ActionRuntime implements Windows.AI.Actions.IActionRuntime, Windows.AI.Actions.IActionRuntime2, Windows.AI.Actions.IActionRuntime3, Windows.Foundation.IClosable {
+ Close(): void;
+ CreateActionFeedback(feedbackKind: number): Windows.AI.Actions.ActionFeedback;
+ CreateInvocationContext(actionId: string): Windows.AI.Actions.ActionInvocationContext;
+ CreateInvocationContextWithWindowId(actionId: string, invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.ActionInvocationContext;
+ GetActionAvailability(actionId: string): boolean;
+ GetActionEntityById(entityId: string): Windows.AI.Actions.ActionEntity;
+ SetActionAvailability(actionId: string, isAvailable: boolean): void;
+ readonly ActionCatalog: Windows.AI.Actions.Hosting.ActionCatalog;
+ readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+ readonly LatestSupportedSchemaVersion: number;
+ }
+
+ class ContactActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IContactActionEntity {
+ Close(): void;
+ readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+ }
+
+ class DocumentActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IDocumentActionEntity {
+ Close(): void;
+ readonly FullPath: string;
+ }
+
+ class FileActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IFileActionEntity {
+ Close(): void;
+ readonly FullPath: string;
+ }
+
+ class NamedActionEntity implements Windows.AI.Actions.INamedActionEntity, Windows.Foundation.IClosable {
+ Close(): void;
+ Entity: Windows.AI.Actions.ActionEntity;
+ Name: string;
+ }
+
+ class PhotoActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IPhotoActionEntity {
+ Close(): void;
+ readonly FullPath: string;
+ }
+
+ class RemoteFileActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IRemoteFileActionEntity {
+ Close(): void;
+ readonly AccountId: string;
+ readonly ContentType: string;
+ readonly DriveId: string;
+ readonly Extension: string;
+ readonly FileId: string;
+ readonly FileKind: number;
+ readonly SourceId: string;
+ readonly SourceUri: Windows.Foundation.Uri;
+ }
+
+ class StreamingTextActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IStreamingTextActionEntity {
+ Close(): void;
+ GetText(): string;
+ readonly IsComplete: boolean;
+ readonly TextFormat: number;
+ TextChanged: Windows.Foundation.TypedEventHandler | null;
+ }
+
+ class StreamingTextActionEntityTextChangedArgs implements Windows.AI.Actions.IStreamingTextActionEntityTextChangedArgs {
+ readonly IsComplete: boolean;
+ readonly Text: string;
+ }
+
+ class StreamingTextActionEntityWriter implements Windows.AI.Actions.IStreamingTextActionEntityWriter, Windows.Foundation.IClosable {
+ Close(): void;
+ SetText(text: string): void;
+ readonly ReaderEntity: Windows.AI.Actions.StreamingTextActionEntity;
+ readonly TextFormat: number;
+ }
+
+ class TableActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.ITableActionEntity {
+ Close(): void;
+ GetTextContent(): string[];
+ readonly ColumnCount: number;
+ readonly RowCount: number;
+ }
+
+ class TextActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.ITextActionEntity, Windows.AI.Actions.ITextActionEntity2 {
+ Close(): void;
+ readonly Text: string;
+ readonly TextFormat: number;
+ }
+
+ enum ActionEntityKind {
+ None = 0,
+ Document = 1,
+ File = 2,
+ Photo = 3,
+ Text = 4,
+ StreamingText = 5,
+ RemoteFile = 6,
+ Table = 7,
+ Contact = 8,
+ }
+
+ enum ActionEntityTextFormat {
+ Plain = 0,
+ Markdown = 1,
+ }
+
+ enum ActionFeedbackKind {
+ Positive = 0,
+ Negative = 1,
+ }
+
+ enum ActionInvocationHelpKind {
+ None = 0,
+ Error = 1,
+ Warning = 2,
+ }
+
+ enum ActionInvocationResult {
+ Success = 0,
+ UserCanceled = 1,
+ Unsupported = 2,
+ Unavailable = 3,
+ }
+
+ enum RemoteFileKind {
+ Document = 0,
+ Photo = 1,
+ File = 2,
+ }
+
+ interface ActionsContract {
+ }
+ var ActionsContract: {
+ new(fields: { }): ActionsContract;
+ };
+
+ interface IActionEntity {
+ readonly DisplayInfo: Windows.AI.Actions.ActionEntityDisplayInfo;
+ readonly Kind: number;
+ }
+ var IActionEntity: abstract new (...args: any[]) => IActionEntity;
+
+ interface IActionEntity2 {
+ readonly Id: string;
+ }
+ var IActionEntity2: abstract new (...args: any[]) => IActionEntity2;
+
+ interface IActionEntityDisplayInfo {
+ readonly Title: string;
+ }
+ var IActionEntityDisplayInfo: abstract new (...args: any[]) => IActionEntityDisplayInfo;
+
+ interface IActionEntityFactory {
+ }
+ var IActionEntityFactory: abstract new (...args: any[]) => IActionEntityFactory;
+
+ interface IActionEntityFactory2 {
+ CreateDocumentEntity(path: string): Windows.AI.Actions.DocumentActionEntity;
+ CreateFileEntity(path: string): Windows.AI.Actions.FileActionEntity;
+ CreatePhotoEntity(path: string): Windows.AI.Actions.PhotoActionEntity;
+ CreateTextEntity(text: string): Windows.AI.Actions.TextActionEntity;
+ }
+ var IActionEntityFactory2: abstract new (...args: any[]) => IActionEntityFactory2;
+
+ interface IActionEntityFactory3 {
+ CreateRemoteFileEntity(sourceId: string, fileKind: number, sourceUri: Windows.Foundation.Uri, fileId: string, contentType: string, driveId: string, accountId: string, extension: string): Windows.AI.Actions.RemoteFileActionEntity;
+ CreateStreamingTextActionEntityWriter(textFormat: number): Windows.AI.Actions.StreamingTextActionEntityWriter;
+ CreateTextEntity(text: string, textFormat: number): Windows.AI.Actions.TextActionEntity;
+ }
+ var IActionEntityFactory3: abstract new (...args: any[]) => IActionEntityFactory3;
+
+ interface IActionEntityFactory4 {
+ CreateContactEntity(contact: Windows.ApplicationModel.Contacts.Contact): Windows.AI.Actions.ContactActionEntity;
+ CreateTableEntity(data: string[], columnCount: number): Windows.AI.Actions.TableActionEntity;
+ }
+ var IActionEntityFactory4: abstract new (...args: any[]) => IActionEntityFactory4;
+
+ interface IActionEntityFactoryFactory {
+ }
+ var IActionEntityFactoryFactory: abstract new (...args: any[]) => IActionEntityFactoryFactory;
+
+ interface IActionFeedback {
+ readonly FeedbackKind: number;
+ }
+ var IActionFeedback: abstract new (...args: any[]) => IActionFeedback;
+
+ interface IActionInvocationContext {
+ GetInputEntities(): Windows.AI.Actions.NamedActionEntity[];
+ GetOutputEntities(): Windows.AI.Actions.NamedActionEntity[];
+ SetInputEntity(inputName: string, inputValue: Windows.AI.Actions.ActionEntity): void;
+ SetOutputEntity(outputName: string, outputValue: Windows.AI.Actions.ActionEntity): void;
+ readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+ ExtendedError: Windows.Foundation.HResult;
+ Result: number;
+ }
+ var IActionInvocationContext: abstract new (...args: any[]) => IActionInvocationContext;
+
+ interface IActionInvocationContext2 {
+ readonly ActionId: string;
+ readonly HelpDetails: Windows.AI.Actions.ActionInvocationHelpDetails;
+ readonly InvokerAppUserModelId: string;
+ readonly InvokerWindowId: Windows.UI.WindowId;
+ }
+ var IActionInvocationContext2: abstract new (...args: any[]) => IActionInvocationContext2;
+
+ interface IActionInvocationHelpDetails {
+ Description: string;
+ HelpUri: Windows.Foundation.Uri;
+ HelpUriDescription: string;
+ Kind: number;
+ Title: string;
+ }
+ var IActionInvocationHelpDetails: abstract new (...args: any[]) => IActionInvocationHelpDetails;
+
+ interface IActionRuntime {
+ CreateInvocationContext(actionId: string): Windows.AI.Actions.ActionInvocationContext;
+ readonly ActionCatalog: Windows.AI.Actions.Hosting.ActionCatalog;
+ readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+ }
+ var IActionRuntime: abstract new (...args: any[]) => IActionRuntime;
+
+ interface IActionRuntime2 {
+ CreateActionFeedback(feedbackKind: number): Windows.AI.Actions.ActionFeedback;
+ GetActionAvailability(actionId: string): boolean;
+ SetActionAvailability(actionId: string, isAvailable: boolean): void;
+ }
+ var IActionRuntime2: abstract new (...args: any[]) => IActionRuntime2;
+
+ interface IActionRuntime3 {
+ CreateInvocationContextWithWindowId(actionId: string, invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.ActionInvocationContext;
+ GetActionEntityById(entityId: string): Windows.AI.Actions.ActionEntity;
+ readonly LatestSupportedSchemaVersion: number;
+ }
+ var IActionRuntime3: abstract new (...args: any[]) => IActionRuntime3;
+
+ interface IActionRuntimeFactory {
+ }
+ var IActionRuntimeFactory: abstract new (...args: any[]) => IActionRuntimeFactory;
+
+ interface IContactActionEntity {
+ readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+ }
+ var IContactActionEntity: abstract new (...args: any[]) => IContactActionEntity;
+
+ interface IDocumentActionEntity {
+ readonly FullPath: string;
+ }
+ var IDocumentActionEntity: abstract new (...args: any[]) => IDocumentActionEntity;
+
+ interface IFileActionEntity {
+ readonly FullPath: string;
+ }
+ var IFileActionEntity: abstract new (...args: any[]) => IFileActionEntity;
+
+ interface INamedActionEntity {
+ Entity: Windows.AI.Actions.ActionEntity;
+ Name: string;
+ }
+ var INamedActionEntity: abstract new (...args: any[]) => INamedActionEntity;
+
+ interface IPhotoActionEntity {
+ readonly FullPath: string;
+ }
+ var IPhotoActionEntity: abstract new (...args: any[]) => IPhotoActionEntity;
+
+ interface IRemoteFileActionEntity {
+ readonly AccountId: string;
+ readonly ContentType: string;
+ readonly DriveId: string;
+ readonly Extension: string;
+ readonly FileId: string;
+ readonly FileKind: number;
+ readonly SourceId: string;
+ readonly SourceUri: Windows.Foundation.Uri;
+ }
+ var IRemoteFileActionEntity: abstract new (...args: any[]) => IRemoteFileActionEntity;
+
+ interface IStreamingTextActionEntity {
+ GetText(): string;
+ readonly IsComplete: boolean;
+ readonly TextFormat: number;
+ TextChanged: Windows.Foundation.TypedEventHandler | null;
+ }
+ var IStreamingTextActionEntity: abstract new (...args: any[]) => IStreamingTextActionEntity;
+
+ interface IStreamingTextActionEntityTextChangedArgs {
+ readonly IsComplete: boolean;
+ readonly Text: string;
+ }
+ var IStreamingTextActionEntityTextChangedArgs: abstract new (...args: any[]) => IStreamingTextActionEntityTextChangedArgs;
+
+ interface IStreamingTextActionEntityWriter {
+ SetText(text: string): void;
+ readonly ReaderEntity: Windows.AI.Actions.StreamingTextActionEntity;
+ readonly TextFormat: number;
+ }
+ var IStreamingTextActionEntityWriter: abstract new (...args: any[]) => IStreamingTextActionEntityWriter;
+
+ interface ITableActionEntity {
+ GetTextContent(): string[];
+ readonly ColumnCount: number;
+ readonly RowCount: number;
+ }
+ var ITableActionEntity: abstract new (...args: any[]) => ITableActionEntity;
+
+ interface ITextActionEntity {
+ readonly Text: string;
+ }
+ var ITextActionEntity: abstract new (...args: any[]) => ITextActionEntity;
+
+ interface ITextActionEntity2 {
+ readonly TextFormat: number;
+ }
+ var ITextActionEntity2: abstract new (...args: any[]) => ITextActionEntity2;
+
+}
+
+declare namespace Windows.AI.Actions.Hosting {
+ class ActionCatalog implements Windows.AI.Actions.Hosting.IActionCatalog, Windows.AI.Actions.Hosting.IActionCatalog2, Windows.Foundation.IClosable {
+ Close(): void;
+ GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[]): Windows.AI.Actions.Hosting.ActionInstance[];
+ GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[], invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.Hosting.ActionInstance[];
+ GetAllActions(): Windows.AI.Actions.Hosting.ActionDefinition[];
+ Changed: Windows.Foundation.TypedEventHandler | null;
+ }
+
+ class ActionDefinition implements Windows.AI.Actions.Hosting.IActionDefinition, Windows.AI.Actions.Hosting.IActionDefinition2, Windows.AI.Actions.Hosting.IActionDefinition3, Windows.Foundation.IClosable {
+ Close(): void;
+ GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ GetOutputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ GetOverloads(): Windows.AI.Actions.Hosting.ActionOverload[];
+ readonly Description: string;
+ readonly DisplaysUI: boolean;
+ readonly IconFullPath: string;
+ readonly Id: string;
+ readonly PackageFamilyName: string;
+ readonly PackageRelativeApplicationId: string;
+ readonly SchemaVersion: number;
+ readonly UsesGenerativeAI: boolean;
+ }
+
+ class ActionEntityRegistrationInfo implements Windows.AI.Actions.Hosting.IActionEntityRegistrationInfo, Windows.Foundation.IClosable {
+ Close(): void;
+ Kind: number;
+ Name: string;
+ }
+
+ class ActionInstance implements Windows.AI.Actions.Hosting.IActionInstance {
+ InvokeAsync(): Windows.Foundation.IAsyncAction;
+ readonly Context: Windows.AI.Actions.ActionInvocationContext;
+ readonly Definition: Windows.AI.Actions.Hosting.ActionDefinition;
+ readonly DisplayInfo: Windows.AI.Actions.Hosting.ActionInstanceDisplayInfo;
+ }
+
+ class ActionInstanceDisplayInfo implements Windows.AI.Actions.Hosting.IActionInstanceDisplayInfo {
+ readonly Description: string;
+ }
+
+ class ActionOverload implements Windows.AI.Actions.Hosting.IActionOverload, Windows.AI.Actions.Hosting.IActionOverload2, Windows.Foundation.IClosable {
+ Close(): void;
+ GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ GetSupportsFeedback(): boolean;
+ InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+ InvokeFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+ readonly DescriptionTemplate: string;
+ }
+
+ interface IActionCatalog {
+ GetAllActions(): Windows.AI.Actions.Hosting.ActionDefinition[];
+ Changed: Windows.Foundation.TypedEventHandler | null;
+ }
+ var IActionCatalog: abstract new (...args: any[]) => IActionCatalog;
+
+ interface IActionCatalog2 {
+ GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[]): Windows.AI.Actions.Hosting.ActionInstance[];
+ GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[], invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.Hosting.ActionInstance[];
+ }
+ var IActionCatalog2: abstract new (...args: any[]) => IActionCatalog2;
+
+ interface IActionDefinition {
+ GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ GetOutputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ GetOverloads(): Windows.AI.Actions.Hosting.ActionOverload[];
+ readonly Description: string;
+ readonly IconFullPath: string;
+ readonly Id: string;
+ readonly PackageFamilyName: string;
+ }
+ var IActionDefinition: abstract new (...args: any[]) => IActionDefinition;
+
+ interface IActionDefinition2 {
+ readonly DisplaysUI: boolean;
+ readonly SchemaVersion: number;
+ readonly UsesGenerativeAI: boolean;
+ }
+ var IActionDefinition2: abstract new (...args: any[]) => IActionDefinition2;
+
+ interface IActionDefinition3 {
+ readonly PackageRelativeApplicationId: string;
+ }
+ var IActionDefinition3: abstract new (...args: any[]) => IActionDefinition3;
+
+ interface IActionEntityRegistrationInfo {
+ Kind: number;
+ Name: string;
+ }
+ var IActionEntityRegistrationInfo: abstract new (...args: any[]) => IActionEntityRegistrationInfo;
+
+ interface IActionInstance {
+ InvokeAsync(): Windows.Foundation.IAsyncAction;
+ readonly Context: Windows.AI.Actions.ActionInvocationContext;
+ readonly Definition: Windows.AI.Actions.Hosting.ActionDefinition;
+ readonly DisplayInfo: Windows.AI.Actions.Hosting.ActionInstanceDisplayInfo;
+ }
+ var IActionInstance: abstract new (...args: any[]) => IActionInstance;
+
+ interface IActionInstanceDisplayInfo {
+ readonly Description: string;
+ }
+ var IActionInstanceDisplayInfo: abstract new (...args: any[]) => IActionInstanceDisplayInfo;
+
+ interface IActionOverload {
+ GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+ InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+ readonly DescriptionTemplate: string;
+ }
+ var IActionOverload: abstract new (...args: any[]) => IActionOverload;
+
+ interface IActionOverload2 {
+ GetSupportsFeedback(): boolean;
+ InvokeFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+ }
+ var IActionOverload2: abstract new (...args: any[]) => IActionOverload2;
+
+}
+
+declare namespace Windows.AI.Actions.Provider {
+ interface IActionFeedbackHandler {
+ ProcessFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+ }
+ var IActionFeedbackHandler: abstract new (...args: any[]) => IActionFeedbackHandler;
+
+ interface IActionProvider {
+ InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+ }
+ var IActionProvider: abstract new (...args: any[]) => IActionProvider;
+
+}
+
+declare namespace Windows.AI.MachineLearning {
+ class ImageFeatureDescriptor implements Windows.AI.MachineLearning.IImageFeatureDescriptor, Windows.AI.MachineLearning.IImageFeatureDescriptor2, Windows.AI.MachineLearning.ILearningModelFeatureDescriptor {
+ readonly BitmapAlphaMode: number;
+ readonly BitmapPixelFormat: number;
+ readonly Description: string;
+ readonly Height: number;
+ readonly IsRequired: boolean;
+ readonly Kind: number;
+ readonly Name: string;
+ readonly PixelRange: number;
+ readonly Width: number;
+ }
+
+ class ImageFeatureValue implements Windows.AI.MachineLearning.IImageFeatureValue, Windows.AI.MachineLearning.ILearningModelFeatureValue {
+ static CreateFromVideoFrame(image: Windows.Media.VideoFrame): Windows.AI.MachineLearning.ImageFeatureValue;
+ readonly Kind: number;
+ readonly VideoFrame: Windows.Media.VideoFrame;
+ }
+
+ class LearningModel implements Windows.AI.MachineLearning.ILearningModel, Windows.Foundation.IClosable {
+ Close(): void;
+ static LoadFromFilePath(filePath: string): Windows.AI.MachineLearning.LearningModel;
+ static LoadFromFilePath(filePath: string, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+ static LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation;
+ static LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation;
+ static LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.AI.MachineLearning.LearningModel;
+ static LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+ static LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation;
+ static LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation;
+ readonly Author: string;
+ readonly Description: string;
+ readonly Domain: string;
+ readonly InputFeatures: Windows.Foundation.Collections.IVectorView | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+ readonly Metadata: Windows.Foundation.Collections.IMapView;
+ readonly Name: string;
+ readonly OutputFeatures: Windows.Foundation.Collections.IVectorView | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+ readonly Version: number | bigint;
+ }
+
+ class LearningModelBinding implements Windows.AI.MachineLearning.ILearningModelBinding {
+ constructor(session: Windows.AI.MachineLearning.LearningModelSession);
+ Bind(name: string, value: Object): void;
+ Bind(name: string, value: Object, props: Windows.Foundation.Collections.IPropertySet): void;
+ Clear(): void;
+ First(): Windows.Foundation.Collections.IIterator>;
+ HasKey(key: string): boolean;
+ Lookup(key: string): Object;
+ Split(first: Windows.Foundation.Collections.IMapView, second: Windows.Foundation.Collections.IMapView): void;
+ readonly Size: number;
+ }
+
+ class LearningModelDevice implements Windows.AI.MachineLearning.ILearningModelDevice {
+ constructor(deviceKind: number);
+ static CreateFromDirect3D11Device(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.AI.MachineLearning.LearningModelDevice;
+ readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+ readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+ }
+
+ class LearningModelEvaluationResult implements Windows.AI.MachineLearning.ILearningModelEvaluationResult {
+ readonly CorrelationId: string;
+ readonly ErrorStatus: number;
+ readonly Outputs: Windows.Foundation.Collections.IMapView;
+ readonly Succeeded: boolean;
+ }
+
+ class LearningModelSession implements Windows.AI.MachineLearning.ILearningModelSession, Windows.Foundation.IClosable {
+ constructor(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice, learningModelSessionOptions: Windows.AI.MachineLearning.LearningModelSessionOptions);
+ constructor(model: Windows.AI.MachineLearning.LearningModel);
+ constructor(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice);
+ Close(): void;
+ Evaluate(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+ EvaluateAsync(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.Foundation.IAsyncOperation;
+ EvaluateFeatures(features: Windows.Foundation.Collections.IMap | Record, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+ EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap | Record, correlationId: string): Windows.Foundation.IAsyncOperation;
+ readonly Device: Windows.AI.MachineLearning.LearningModelDevice;
+ readonly EvaluationProperties: Windows.Foundation.Collections.IPropertySet;
+ readonly Model: Windows.AI.MachineLearning.LearningModel;
+ }
+
+ class LearningModelSessionOptions implements Windows.AI.MachineLearning.ILearningModelSessionOptions, Windows.AI.MachineLearning.ILearningModelSessionOptions2, Windows.AI.MachineLearning.ILearningModelSessionOptions3 {
+ constructor();
+ OverrideNamedDimension(name: string, dimension: number): void;
+ BatchSizeOverride: number;
+ CloseModelOnSessionCreation: boolean;
+ }
+
+ class MapFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.IMapFeatureDescriptor {
+ readonly Description: string;
+ readonly IsRequired: boolean;
+ readonly KeyKind: number;
+ readonly Kind: number;
+ readonly Name: string;
+ readonly ValueDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+ }
+
+ class SequenceFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.ISequenceFeatureDescriptor {
+ readonly Description: string;
+ readonly ElementDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+ readonly IsRequired: boolean;
+ readonly Kind: number;
+ readonly Name: string;
+ }
+
+ class TensorBoolean implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorBoolean, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorBoolean;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorBoolean;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorBoolean;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | boolean[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorDouble implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorDouble, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorDouble;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorDouble;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorDouble;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorDouble;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.ITensorFeatureDescriptor {
+ readonly Description: string;
+ readonly IsRequired: boolean;
+ readonly Kind: number;
+ readonly Name: string;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorFloat implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorFloat, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorFloat;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorFloat;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorFloat;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorFloat16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorFloat16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorFloat16Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat16Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorInt16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorInt16Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt16Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorInt32Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt32Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorInt32Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt32Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorInt64Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt64Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorInt64Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt64Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorInt8Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt8Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorInt8Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt8Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt8Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorString implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorString, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorString;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorString;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | string[]): Windows.AI.MachineLearning.TensorString;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | string[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorUInt16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorUInt16Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt16Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorUInt32Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt32Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorUInt32Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt32Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorUInt64Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt64Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorUInt64Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt64Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ class TensorUInt8Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt8Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+ Close(): void;
+ static Create(): Windows.AI.MachineLearning.TensorUInt8Bit;
+ static Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+ static CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+ static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt8Bit;
+ static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+ static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+ CreateReference(): Windows.Foundation.IMemoryBufferReference;
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ readonly Kind: number;
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+
+ enum LearningModelDeviceKind {
+ Default = 0,
+ Cpu = 1,
+ DirectX = 2,
+ DirectXHighPerformance = 3,
+ DirectXMinPower = 4,
+ }
+
+ enum LearningModelFeatureKind {
+ Tensor = 0,
+ Sequence = 1,
+ Map = 2,
+ Image = 3,
+ }
+
+ enum LearningModelPixelRange {
+ ZeroTo255 = 0,
+ ZeroToOne = 1,
+ MinusOneToOne = 2,
+ }
+
+ enum TensorKind {
+ Undefined = 0,
+ Float = 1,
+ UInt8 = 2,
+ Int8 = 3,
+ UInt16 = 4,
+ Int16 = 5,
+ Int32 = 6,
+ Int64 = 7,
+ String = 8,
+ Boolean = 9,
+ Float16 = 10,
+ Double = 11,
+ UInt32 = 12,
+ UInt64 = 13,
+ Complex64 = 14,
+ Complex128 = 15,
+ }
+
+ interface IImageFeatureDescriptor {
+ readonly BitmapAlphaMode: number;
+ readonly BitmapPixelFormat: number;
+ readonly Height: number;
+ readonly Width: number;
+ }
+ var IImageFeatureDescriptor: abstract new (...args: any[]) => IImageFeatureDescriptor;
+
+ interface IImageFeatureDescriptor2 {
+ readonly PixelRange: number;
+ }
+ var IImageFeatureDescriptor2: abstract new (...args: any[]) => IImageFeatureDescriptor2;
+
+ interface IImageFeatureValue {
+ readonly VideoFrame: Windows.Media.VideoFrame;
+ }
+ var IImageFeatureValue: abstract new (...args: any[]) => IImageFeatureValue;
+
+ interface IImageFeatureValueStatics {
+ CreateFromVideoFrame(image: Windows.Media.VideoFrame): Windows.AI.MachineLearning.ImageFeatureValue;
+ }
+ var IImageFeatureValueStatics: abstract new (...args: any[]) => IImageFeatureValueStatics;
+
+ interface ILearningModel {
+ readonly Author: string;
+ readonly Description: string;
+ readonly Domain: string;
+ readonly InputFeatures: Windows.Foundation.Collections.IVectorView | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+ readonly Metadata: Windows.Foundation.Collections.IMapView;
+ readonly Name: string;
+ readonly OutputFeatures: Windows.Foundation.Collections.IVectorView | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+ readonly Version: number | bigint;
+ }
+ var ILearningModel: abstract new (...args: any[]) => ILearningModel;
+
+ interface ILearningModelBinding {
+ Bind(name: string, value: Object): void;
+ Bind(name: string, value: Object, props: Windows.Foundation.Collections.IPropertySet): void;
+ Clear(): void;
+ }
+ var ILearningModelBinding: abstract new (...args: any[]) => ILearningModelBinding;
+
+ interface ILearningModelBindingFactory {
+ CreateFromSession(session: Windows.AI.MachineLearning.LearningModelSession): Windows.AI.MachineLearning.LearningModelBinding;
+ }
+ var ILearningModelBindingFactory: abstract new (...args: any[]) => ILearningModelBindingFactory;
+
+ interface ILearningModelDevice {
+ readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+ readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+ }
+ var ILearningModelDevice: abstract new (...args: any[]) => ILearningModelDevice;
+
+ interface ILearningModelDeviceFactory {
+ Create(deviceKind: number): Windows.AI.MachineLearning.LearningModelDevice;
+ }
+ var ILearningModelDeviceFactory: abstract new (...args: any[]) => ILearningModelDeviceFactory;
+
+ interface ILearningModelDeviceStatics {
+ CreateFromDirect3D11Device(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.AI.MachineLearning.LearningModelDevice;
+ }
+ var ILearningModelDeviceStatics: abstract new (...args: any[]) => ILearningModelDeviceStatics;
+
+ interface ILearningModelEvaluationResult {
+ readonly CorrelationId: string;
+ readonly ErrorStatus: number;
+ readonly Outputs: Windows.Foundation.Collections.IMapView;
+ readonly Succeeded: boolean;
+ }
+ var ILearningModelEvaluationResult: abstract new (...args: any[]) => ILearningModelEvaluationResult;
+
+ interface ILearningModelFeatureDescriptor {
+ readonly Description: string;
+ readonly IsRequired: boolean;
+ readonly Kind: number;
+ readonly Name: string;
+ }
+ var ILearningModelFeatureDescriptor: abstract new (...args: any[]) => ILearningModelFeatureDescriptor;
+
+ interface ILearningModelFeatureValue {
+ readonly Kind: number;
+ }
+ var ILearningModelFeatureValue: abstract new (...args: any[]) => ILearningModelFeatureValue;
+
+ interface ILearningModelOperatorProvider {
+ }
+ var ILearningModelOperatorProvider: abstract new (...args: any[]) => ILearningModelOperatorProvider;
+
+ interface ILearningModelSession {
+ Evaluate(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+ EvaluateAsync(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.Foundation.IAsyncOperation;
+ EvaluateFeatures(features: Windows.Foundation.Collections.IMap | Record, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+ EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap | Record, correlationId: string): Windows.Foundation.IAsyncOperation;
+ readonly Device: Windows.AI.MachineLearning.LearningModelDevice;
+ readonly EvaluationProperties: Windows.Foundation.Collections.IPropertySet;
+ readonly Model: Windows.AI.MachineLearning.LearningModel;
+ }
+ var ILearningModelSession: abstract new (...args: any[]) => ILearningModelSession;
+
+ interface ILearningModelSessionFactory {
+ CreateFromModel(model: Windows.AI.MachineLearning.LearningModel): Windows.AI.MachineLearning.LearningModelSession;
+ CreateFromModelOnDevice(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice): Windows.AI.MachineLearning.LearningModelSession;
+ }
+ var ILearningModelSessionFactory: abstract new (...args: any[]) => ILearningModelSessionFactory;
+
+ interface ILearningModelSessionFactory2 {
+ CreateFromModelOnDeviceWithSessionOptions(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice, learningModelSessionOptions: Windows.AI.MachineLearning.LearningModelSessionOptions): Windows.AI.MachineLearning.LearningModelSession;
+ }
+ var ILearningModelSessionFactory2: abstract new (...args: any[]) => ILearningModelSessionFactory2;
+
+ interface ILearningModelSessionOptions {
+ BatchSizeOverride: number;
+ }
+ var ILearningModelSessionOptions: abstract new (...args: any[]) => ILearningModelSessionOptions;
+
+ interface ILearningModelSessionOptions2 {
+ CloseModelOnSessionCreation: boolean;
+ }
+ var ILearningModelSessionOptions2: abstract new (...args: any[]) => ILearningModelSessionOptions2;
+
+ interface ILearningModelSessionOptions3 {
+ OverrideNamedDimension(name: string, dimension: number): void;
+ }
+ var ILearningModelSessionOptions3: abstract new (...args: any[]) => ILearningModelSessionOptions3;
+
+ interface ILearningModelStatics {
+ LoadFromFilePath(filePath: string): Windows.AI.MachineLearning.LearningModel;
+ LoadFromFilePath(filePath: string, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+ LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation;
+ LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation;
+ LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.AI.MachineLearning.LearningModel;
+ LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+ LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation;
+ LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation;
+ }
+ var ILearningModelStatics: abstract new (...args: any[]) => ILearningModelStatics;
+
+ interface IMapFeatureDescriptor {
+ readonly KeyKind: number;
+ readonly ValueDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+ }
+ var IMapFeatureDescriptor: abstract new (...args: any[]) => IMapFeatureDescriptor;
+
+ interface ISequenceFeatureDescriptor {
+ readonly ElementDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+ }
+ var ISequenceFeatureDescriptor: abstract new (...args: any[]) => ISequenceFeatureDescriptor;
+
+ interface ITensor extends Windows.AI.MachineLearning.ILearningModelFeatureValue {
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+ var ITensor: abstract new (...args: any[]) => ITensor;
+
+ interface ITensorBoolean {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | boolean[];
+ }
+ var ITensorBoolean: abstract new (...args: any[]) => ITensorBoolean;
+
+ interface ITensorBooleanStatics {
+ Create(): Windows.AI.MachineLearning.TensorBoolean;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorBoolean;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ }
+ var ITensorBooleanStatics: abstract new (...args: any[]) => ITensorBooleanStatics;
+
+ interface ITensorBooleanStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorBoolean;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+ }
+ var ITensorBooleanStatics2: abstract new (...args: any[]) => ITensorBooleanStatics2;
+
+ interface ITensorDouble {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ }
+ var ITensorDouble: abstract new (...args: any[]) => ITensorDouble;
+
+ interface ITensorDoubleStatics {
+ Create(): Windows.AI.MachineLearning.TensorDouble;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorDouble;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorDouble;
+ }
+ var ITensorDoubleStatics: abstract new (...args: any[]) => ITensorDoubleStatics;
+
+ interface ITensorDoubleStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorDouble;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+ }
+ var ITensorDoubleStatics2: abstract new (...args: any[]) => ITensorDoubleStatics2;
+
+ interface ITensorFeatureDescriptor {
+ readonly Shape: Windows.Foundation.Collections.IVectorView | number | bigint[];
+ readonly TensorKind: number;
+ }
+ var ITensorFeatureDescriptor: abstract new (...args: any[]) => ITensorFeatureDescriptor;
+
+ interface ITensorFloat {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ }
+ var ITensorFloat: abstract new (...args: any[]) => ITensorFloat;
+
+ interface ITensorFloat16Bit {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ }
+ var ITensorFloat16Bit: abstract new (...args: any[]) => ITensorFloat16Bit;
+
+ interface ITensorFloat16BitStatics {
+ Create(): Windows.AI.MachineLearning.TensorFloat16Bit;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ }
+ var ITensorFloat16BitStatics: abstract new (...args: any[]) => ITensorFloat16BitStatics;
+
+ interface ITensorFloat16BitStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat16Bit;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+ }
+ var ITensorFloat16BitStatics2: abstract new (...args: any[]) => ITensorFloat16BitStatics2;
+
+ interface ITensorFloatStatics {
+ Create(): Windows.AI.MachineLearning.TensorFloat;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorFloat;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorFloat;
+ }
+ var ITensorFloatStatics: abstract new (...args: any[]) => ITensorFloatStatics;
+
+ interface ITensorFloatStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+ }
+ var ITensorFloatStatics2: abstract new (...args: any[]) => ITensorFloatStatics2;
+
+ interface ITensorInt16Bit {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ }
+ var ITensorInt16Bit: abstract new (...args: any[]) => ITensorInt16Bit;
+
+ interface ITensorInt16BitStatics {
+ Create(): Windows.AI.MachineLearning.TensorInt16Bit;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ }
+ var ITensorInt16BitStatics: abstract new (...args: any[]) => ITensorInt16BitStatics;
+
+ interface ITensorInt16BitStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt16Bit;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+ }
+ var ITensorInt16BitStatics2: abstract new (...args: any[]) => ITensorInt16BitStatics2;
+
+ interface ITensorInt32Bit {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView | number[];
+ }
+ var ITensorInt32Bit: abstract new (...args: any[]) => ITensorInt32Bit;
+
+ interface ITensorInt32BitStatics {
+ Create(): Windows.AI.MachineLearning.TensorInt32Bit;
+ Create(shape: Windows.Foundation.Collections.IIterable | number | bigint[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ CreateFromArray(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ CreateFromIterable(shape: Windows.Foundation.Collections.IIterable | number | bigint[], data: Windows.Foundation.Collections.IIterable | number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ }
+ var ITensorInt32BitStatics: abstract new (...args: any[]) => ITensorInt32BitStatics;
+
+ interface ITensorInt32BitStatics2 {
+ CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt32Bit;
+ CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+ }
+ var ITensorInt32BitStatics2: abstract new (...args: any[]) => ITensorInt32BitStatics2;
+
+ interface ITensorInt64Bit {
+ GetAsVectorView(): Windows.Foundation.Collections.IVectorView