@nativescript/core 9.0.0-next-09-09-2025-17590373424 → 9.0.0-next-09-19-2025-17844486041

package/application/application.ios.js

@@ -1,8 +1,15 @@
 import { profile } from '../profiling';
 import { isEmbedded } from '../ui/embedding';
 import { IOSHelper } from '../ui/core/view/view-helper';
-import * as Utils from '../utils';
-import { ApplicationCommon } from './application-common';
+import { getWindow } from '../utils/native-helper';
+import { SDK_VERSION } from '../utils/constants';
+import { ios as iosUtils } from '../utils/native-helper';
+import { ApplicationCommon, initializeSdkVersionClass } from './application-common';
+import { Observable } from '../data/observable';
+import { Trace } from '../trace';
+import { AccessibilityServiceEnabledPropName, CommonA11YServiceEnabledObservable, SharedA11YObservable, a11yServiceClasses, a11yServiceDisabledClass, a11yServiceEnabledClass, fontScaleCategoryClasses, fontScaleExtraLargeCategoryClass, fontScaleExtraSmallCategoryClass, fontScaleMediumCategoryClass, getCurrentA11YServiceClass, getCurrentFontScaleCategory, getCurrentFontScaleClass, getFontScaleCssClasses, setCurrentA11YServiceClass, setCurrentFontScaleCategory, setCurrentFontScaleClass, setFontScaleCssClasses, FontScaleCategory, getClosestValidFontScale, VALID_FONT_SCALES, setFontScale, getFontScale, setInitFontScale, getFontScaleCategory, setInitAccessibilityCssHelper, notifyAccessibilityFocusState, AccessibilityLiveRegion, AccessibilityRole, AccessibilityState, AccessibilityTrait, isA11yEnabled, setA11yEnabled, enforceArray, } from '../accessibility/accessibility-common';
+import { iosAddNotificationObserver, iosRemoveNotificationObserver } from './helpers';
+import { getiOSWindow, setA11yUpdatePropertiesCallback, setApplicationPropertiesCallback, setAppMainEntry, setiOSWindow, setRootView, setToggleApplicationEventListenersCallback } from './helpers-common';
 var CADisplayLinkTarget = /** @class */ (function (_super) {
     __extends(CADisplayLinkTarget, _super);
     function CADisplayLinkTarget() {
@@ -33,24 +40,6 @@ var CADisplayLinkTarget = /** @class */ (function (_super) {
     };
     return CADisplayLinkTarget;
 }(NSObject));
-var NotificationObserver = /** @class */ (function (_super) {
-    __extends(NotificationObserver, _super);
-    function NotificationObserver() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NotificationObserver.initWithCallback = function (onReceiveCallback) {
-        var observer = _super.new.call(this);
-        observer._onReceiveCallback = onReceiveCallback;
-        return observer;
-    };
-    NotificationObserver.prototype.onReceive = function (notification) {
-        this._onReceiveCallback(notification);
-    };
-    NotificationObserver.ObjCExposedMethods = {
-        onReceive: { returns: interop.types.void, params: [NSNotification] },
-    };
-    return NotificationObserver;
-}(NSObject));
 var Responder = /** @class */ (function (_super) {
     __extends(Responder, _super);
     function Responder() {
@@ -76,7 +65,6 @@ export class iOSApplication extends ApplicationCommon {
     constructor() {
         super();
         this._delegateHandlers = new Map();
-        this._notificationObservers = [];
         this.displayedOnce = false;
         this.addNotificationObserver(UIApplicationDidFinishLaunchingNotification, this.didFinishLaunchingWithOptions.bind(this));
         this.addNotificationObserver(UIApplicationDidBecomeActiveNotification, this.didBecomeActive.bind(this));
@@ -93,7 +81,7 @@ export class iOSApplication extends ApplicationCommon {
         this.setWindowContent();
     }
     run(entry) {
-        this.mainEntry = typeof entry === 'string' ? { moduleName: entry } : entry;
+        setAppMainEntry(typeof entry === 'string' ? { moduleName: entry } : entry);
         this.started = true;
         if (this.nativeApp) {
             this.runAsEmbeddedApp();
@@ -112,8 +100,9 @@ export class iOSApplication extends ApplicationCommon {
             return;
         }
         this._rootView = rootView;
+        setRootView(rootView);
         // Attach to the existing iOS app
-        const window = Utils.ios.getWindow();
+        const window = getWindow();
         if (!window) {
             return;
         }
@@ -134,7 +123,7 @@ export class iOSApplication extends ApplicationCommon {
             embedderDelegate.presentNativeScriptApp(controller);
         }
         else {
-            const visibleVC = Utils.ios.getVisibleViewController(rootController);
+            const visibleVC = iosUtils.getVisibleViewController(rootController);
             visibleVC.presentViewControllerAnimatedCompletion(controller, true, null);
         }
         this.initRootView(rootView);
@@ -168,7 +157,7 @@ export class iOSApplication extends ApplicationCommon {
             const minFrameRateDisabled = NSBundle.mainBundle.objectForInfoDictionaryKey('CADisableMinimumFrameDurationOnPhone');
             if (minFrameRateDisabled) {
                 let max = 120;
-                const deviceMaxFrames = Utils.ios.getMainScreen().maximumFramesPerSecond;
+                const deviceMaxFrames = iosUtils.getMainScreen().maximumFramesPerSecond;
                 if (options?.max) {
                     if (deviceMaxFrames) {
                         // iOS 10.3
@@ -179,7 +168,7 @@ export class iOSApplication extends ApplicationCommon {
                         max = options.max <= this.displayedLink.preferredFramesPerSecond ? options.max : this.displayedLink.preferredFramesPerSecond;
                     }
                 }
-                if (Utils.SDK_VERSION >= 15 || __VISIONOS__) {
+                if (SDK_VERSION >= 15 || __VISIONOS__) {
                     const min = options?.min || max / 2;
                     const preferred = options?.preferred || max;
                     this.displayedLink.preferredFrameRateRange = CAFrameRateRangeMake(min, max, preferred);
@@ -209,11 +198,11 @@ export class iOSApplication extends ApplicationCommon {
         // TODO: consideration
         // may not want to cache this value given the potential of multiple scenes
         // particularly with SwiftUI app lifecycle based apps
-        if (!this._window) {
+        if (!getiOSWindow()) {
             // Note: NativeScriptViewFactory.getKeyWindow will always be used in SwiftUI app lifecycle based apps
-            this._window = Utils.ios.getWindow();
+            setiOSWindow(getWindow());
         }
-        return this._window;
+        return getiOSWindow();
     }
     get delegate() {
         return this._delegate;
@@ -257,21 +246,14 @@ export class iOSApplication extends ApplicationCommon {
         return this.nativeApp;
     }
     addNotificationObserver(notificationName, onReceiveCallback) {
-        const observer = NotificationObserver.initWithCallback(onReceiveCallback);
-        NSNotificationCenter.defaultCenter.addObserverSelectorNameObject(observer, 'onReceive', notificationName, null);
-        this._notificationObservers.push(observer);
-        return observer;
+        return iosAddNotificationObserver(notificationName, onReceiveCallback);
     }
-    removeNotificationObserver(observer, notificationName) {
-        const index = this._notificationObservers.indexOf(observer);
-        if (index >= 0) {
-            this._notificationObservers.splice(index, 1);
-            NSNotificationCenter.defaultCenter.removeObserverNameObject(observer, notificationName, null);
-        }
+    removeNotificationObserver(observer /* NotificationObserver */, notificationName) {
+        iosRemoveNotificationObserver(observer, notificationName);
     }
     getSystemAppearance() {
         // userInterfaceStyle is available on UITraitCollection since iOS 12.
-        if ((!__VISIONOS__ && Utils.SDK_VERSION <= 11) || !this.rootController) {
+        if ((!__VISIONOS__ && SDK_VERSION <= 11) || !this.rootController) {
             return null;
         }
         const userInterfaceStyle = this.rootController.traitCollection.userInterfaceStyle;
@@ -312,13 +294,13 @@ export class iOSApplication extends ApplicationCommon {
         const root = this.notifyLaunch({
             ios: notification?.userInfo?.objectForKey('UIApplicationLaunchOptionsLocalNotificationKey') ?? null,
         });
-        if (this._window) {
+        if (getiOSWindow()) {
             if (root !== null && !isEmbedded()) {
                 this.setWindowContent(root);
             }
         }
         else {
-            this._window = this.window; // UIApplication.sharedApplication.keyWindow;
+            setiOSWindow(this.window);
         }
     }
     _onLivesync(context) {
@@ -342,6 +324,7 @@ export class iOSApplication extends ApplicationCommon {
         const rootView = this.createRootView(view);
         const controller = this.getViewController(rootView);
         this._rootView = rootView;
+        setRootView(rootView);
         // setup view as styleScopeHost
         rootView._setupAsRootView({});
         this.setViewControllerView(rootView);
@@ -360,15 +343,29 @@ export class iOSApplication extends ApplicationCommon {
     }
     // Observers
     didFinishLaunchingWithOptions(notification) {
+        if (__DEV__) {
+            /**
+             * v9+ runtime crash handling
+             * When crash occurs during boot, we let runtime take over
+             */
+            if (notification.userInfo) {
+                const isBootCrash = notification.userInfo.objectForKey('NativeScriptBootCrash');
+                if (isBootCrash) {
+                    // fatal crash will show in console without app exiting
+                    // allowing hot reload fixes to continue
+                    return;
+                }
+            }
+        }
         this.setMaxRefreshRate();
         // ensures window is assigned to proper window scene
-        this._window = this.window;
-        if (!this._window) {
+        setiOSWindow(this.window);
+        if (!getiOSWindow()) {
             // if still no window, create one
-            this._window = UIWindow.alloc().initWithFrame(UIScreen.mainScreen.bounds);
+            setiOSWindow(UIWindow.alloc().initWithFrame(UIScreen.mainScreen.bounds));
         }
         if (!__VISIONOS__) {
-            this.window.backgroundColor = Utils.SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
+            this.window.backgroundColor = SDK_VERSION <= 12 || !UIColor.systemBackgroundColor ? UIColor.whiteColor : UIColor.systemBackgroundColor;
         }
         this.notifyAppStarted(notification);
     }
@@ -442,4 +439,433 @@ global.__onLiveSyncCore = function (context) {
 export * from './application-common';
 export const Application = iosApp;
 export const AndroidApplication = undefined;
+function fontScaleChanged(origFontScale) {
+    const oldValue = getFontScale();
+    setFontScale(getClosestValidFontScale(origFontScale));
+    const currentFontScale = getFontScale();
+    if (oldValue !== currentFontScale) {
+        Application.notify({
+            eventName: Application.fontScaleChangedEvent,
+            object: Application,
+            newValue: currentFontScale,
+        });
+    }
+}
+export function getCurrentFontScale() {
+    setupConfigListener();
+    return getFontScale();
+}
+const sizeMap = new Map([
+    [UIContentSizeCategoryExtraSmall, 0.5],
+    [UIContentSizeCategorySmall, 0.7],
+    [UIContentSizeCategoryMedium, 0.85],
+    [UIContentSizeCategoryLarge, 1],
+    [UIContentSizeCategoryExtraLarge, 1.15],
+    [UIContentSizeCategoryExtraExtraLarge, 1.3],
+    [UIContentSizeCategoryExtraExtraExtraLarge, 1.5],
+    [UIContentSizeCategoryAccessibilityMedium, 2],
+    [UIContentSizeCategoryAccessibilityLarge, 2.5],
+    [UIContentSizeCategoryAccessibilityExtraLarge, 3],
+    [UIContentSizeCategoryAccessibilityExtraExtraLarge, 3.5],
+    [UIContentSizeCategoryAccessibilityExtraExtraExtraLarge, 4],
+]);
+function contentSizeUpdated(fontSize) {
+    if (sizeMap.has(fontSize)) {
+        fontScaleChanged(sizeMap.get(fontSize));
+        return;
+    }
+    fontScaleChanged(1);
+}
+function useIOSFontScale() {
+    if (Application.ios.nativeApp) {
+        contentSizeUpdated(Application.ios.nativeApp.preferredContentSizeCategory);
+    }
+    else {
+        fontScaleChanged(1);
+    }
+}
+let fontSizeObserver;
+function setupConfigListener(attempt = 0) {
+    if (fontSizeObserver) {
+        return;
+    }
+    if (!Application.ios.nativeApp) {
+        if (attempt > 100) {
+            fontScaleChanged(1);
+            return;
+        }
+        // Couldn't get launchEvent to trigger.
+        setTimeout(() => setupConfigListener(attempt + 1), 1);
+        return;
+    }
+    fontSizeObserver = Application.ios.addNotificationObserver(UIContentSizeCategoryDidChangeNotification, (args) => {
+        const fontSize = args.userInfo.valueForKey(UIContentSizeCategoryNewValueKey);
+        contentSizeUpdated(fontSize);
+    });
+    Application.on(Application.exitEvent, () => {
+        if (fontSizeObserver) {
+            Application.ios.removeNotificationObserver(fontSizeObserver, UIContentSizeCategoryDidChangeNotification);
+            fontSizeObserver = null;
+        }
+        Application.off(Application.resumeEvent, useIOSFontScale);
+    });
+    Application.on(Application.resumeEvent, useIOSFontScale);
+    useIOSFontScale();
+}
+setInitFontScale(setupConfigListener);
+/**
+ * Convert array of values into a bitmask.
+ *
+ * @param values string values
+ * @param map    map lower-case name to integer value.
+ */
+function inputArrayToBitMask(values, map) {
+    return (enforceArray(values)
+        .filter((value) => !!value)
+        .map((value) => `${value}`.toLocaleLowerCase())
+        .filter((value) => map.has(value))
+        .reduce((res, value) => res | map.get(value), 0) || 0);
+}
+let AccessibilityTraitsMap;
+let RoleTypeMap;
+let nativeFocusedNotificationObserver;
+let lastFocusedView;
+function ensureNativeClasses() {
+    if (AccessibilityTraitsMap && nativeFocusedNotificationObserver) {
+        return;
+    }
+    AccessibilityTraitsMap = new Map([
+        [AccessibilityTrait.AllowsDirectInteraction, UIAccessibilityTraitAllowsDirectInteraction],
+        [AccessibilityTrait.CausesPageTurn, UIAccessibilityTraitCausesPageTurn],
+        [AccessibilityTrait.NotEnabled, UIAccessibilityTraitNotEnabled],
+        [AccessibilityTrait.Selected, UIAccessibilityTraitSelected],
+        [AccessibilityTrait.UpdatesFrequently, UIAccessibilityTraitUpdatesFrequently],
+    ]);
+    RoleTypeMap = new Map([
+        [AccessibilityRole.Adjustable, UIAccessibilityTraitAdjustable],
+        [AccessibilityRole.Button, UIAccessibilityTraitButton],
+        [AccessibilityRole.Checkbox, UIAccessibilityTraitButton],
+        [AccessibilityRole.Header, UIAccessibilityTraitHeader],
+        [AccessibilityRole.KeyboardKey, UIAccessibilityTraitKeyboardKey],
+        [AccessibilityRole.Image, UIAccessibilityTraitImage],
+        [AccessibilityRole.ImageButton, UIAccessibilityTraitImage | UIAccessibilityTraitButton],
+        [AccessibilityRole.Link, UIAccessibilityTraitLink],
+        [AccessibilityRole.None, UIAccessibilityTraitNone],
+        [AccessibilityRole.PlaysSound, UIAccessibilityTraitPlaysSound],
+        [AccessibilityRole.RadioButton, UIAccessibilityTraitButton],
+        [AccessibilityRole.Search, UIAccessibilityTraitSearchField],
+        [AccessibilityRole.StaticText, UIAccessibilityTraitStaticText],
+        [AccessibilityRole.StartsMediaSession, UIAccessibilityTraitStartsMediaSession],
+        [AccessibilityRole.Summary, UIAccessibilityTraitSummaryElement],
+        [AccessibilityRole.Switch, UIAccessibilityTraitButton],
+    ]);
+    nativeFocusedNotificationObserver = Application.ios.addNotificationObserver(UIAccessibilityElementFocusedNotification, (args) => {
+        const uiView = args.userInfo?.objectForKey(UIAccessibilityFocusedElementKey);
+        if (!uiView?.tag) {
+            return;
+        }
+        const rootView = Application.getRootView();
+        // We use the UIView's tag to find the NativeScript View by its domId.
+        let view = rootView.getViewByDomId(uiView?.tag);
+        if (!view) {
+            for (const modalView of rootView._getRootModalViews()) {
+                view = modalView.getViewByDomId(uiView?.tag);
+                if (view) {
+                    break;
+                }
+            }
+        }
+        if (!view) {
+            return;
+        }
+        const lastView = lastFocusedView?.deref();
+        if (lastView && view !== lastView) {
+            const lastFocusedUIView = lastView.nativeViewProtected;
+            if (lastFocusedUIView) {
+                lastFocusedView = null;
+                notifyAccessibilityFocusState(lastView, false, true);
+            }
+        }
+        lastFocusedView = new WeakRef(view);
+        notifyAccessibilityFocusState(view, true, false);
+    });
+    Application.on(Application.exitEvent, () => {
+        if (nativeFocusedNotificationObserver) {
+            Application.ios.removeNotificationObserver(nativeFocusedNotificationObserver, UIAccessibilityElementFocusedNotification);
+        }
+        nativeFocusedNotificationObserver = null;
+        lastFocusedView = null;
+    });
+}
+export function updateAccessibilityProperties(view) {
+    const uiView = view.nativeViewProtected;
+    if (!uiView) {
+        return;
+    }
+    ensureNativeClasses();
+    const accessibilityRole = view.accessibilityRole;
+    const accessibilityState = view.accessibilityState;
+    if (!view.accessible || view.accessibilityHidden) {
+        uiView.accessibilityTraits = UIAccessibilityTraitNone;
+        return;
+    }
+    // NOTE: left here for various core inspection passes while running the toolbox app
+    // console.log('--- Accessible element: ', view.constructor.name);
+    // console.log('accessibilityLabel: ', view.accessibilityLabel);
+    // console.log('accessibilityRole: ', accessibilityRole);
+    // console.log('accessibilityState: ', accessibilityState);
+    // console.log('accessibilityValue: ', view.accessibilityValue);
+    let a11yTraits = UIAccessibilityTraitNone;
+    if (RoleTypeMap.has(accessibilityRole)) {
+        a11yTraits |= RoleTypeMap.get(accessibilityRole);
+    }
+    switch (accessibilityRole) {
+        case AccessibilityRole.Checkbox:
+        case AccessibilityRole.RadioButton:
+        case AccessibilityRole.Switch: {
+            if (accessibilityState === AccessibilityState.Checked) {
+                a11yTraits |= AccessibilityTraitsMap.get(AccessibilityTrait.Selected);
+            }
+            break;
+        }
+        default: {
+            if (accessibilityState === AccessibilityState.Selected) {
+                a11yTraits |= AccessibilityTraitsMap.get(AccessibilityTrait.Selected);
+            }
+            if (accessibilityState === AccessibilityState.Disabled) {
+                a11yTraits |= AccessibilityTraitsMap.get(AccessibilityTrait.NotEnabled);
+            }
+            break;
+        }
+    }
+    const UpdatesFrequentlyTrait = AccessibilityTraitsMap.get(AccessibilityTrait.UpdatesFrequently);
+    switch (view.accessibilityLiveRegion) {
+        case AccessibilityLiveRegion.Polite:
+        case AccessibilityLiveRegion.Assertive: {
+            a11yTraits |= UpdatesFrequentlyTrait;
+            break;
+        }
+        default: {
+            a11yTraits &= ~UpdatesFrequentlyTrait;
+            break;
+        }
+    }
+    // NOTE: left here for various core inspection passes while running the toolbox app
+    // if (view.accessibilityLiveRegion) {
+    // 	console.log('accessibilityLiveRegion:', view.accessibilityLiveRegion);
+    // }
+    if (view.accessibilityMediaSession) {
+        a11yTraits |= RoleTypeMap.get(AccessibilityRole.StartsMediaSession);
+    }
+    // NOTE: There were duplicated types in traits and roles previously which we conslidated
+    // not sure if this is still needed
+    // accessibilityTraits used to be stored on {N} view component but if the above
+    // is combining all traits fresh each time through, don't believe we need to keep track or previous traits
+    // if (view.accessibilityTraits) {
+    // 	a11yTraits |= inputArrayToBitMask(view.accessibilityTraits, AccessibilityTraitsMap);
+    // }
+    // NOTE: left here for various core inspection passes while running the toolbox app
+    // console.log('a11yTraits:', a11yTraits);
+    // console.log('    ');
+    uiView.accessibilityTraits = a11yTraits;
+}
+setA11yUpdatePropertiesCallback(updateAccessibilityProperties);
+export const sendAccessibilityEvent = () => { };
+export function isAccessibilityServiceEnabled() {
+    const accessibilityServiceEnabled = isA11yEnabled();
+    if (typeof accessibilityServiceEnabled === 'boolean') {
+        return accessibilityServiceEnabled;
+    }
+    let isVoiceOverRunning;
+    if (typeof UIAccessibilityIsVoiceOverRunning === 'function') {
+        isVoiceOverRunning = UIAccessibilityIsVoiceOverRunning;
+    }
+    else {
+        // iOS is too old to tell us if voice over is enabled
+        if (typeof UIAccessibilityIsVoiceOverRunning !== 'function') {
+            setA11yEnabled(false);
+            return isA11yEnabled();
+        }
+    }
+    setA11yEnabled(isVoiceOverRunning());
+    let voiceOverStatusChangedNotificationName = null;
+    if (typeof UIAccessibilityVoiceOverStatusDidChangeNotification !== 'undefined') {
+        voiceOverStatusChangedNotificationName = UIAccessibilityVoiceOverStatusDidChangeNotification;
+    }
+    else if (typeof UIAccessibilityVoiceOverStatusChanged !== 'undefined') {
+        voiceOverStatusChangedNotificationName = UIAccessibilityVoiceOverStatusChanged;
+    }
+    if (voiceOverStatusChangedNotificationName) {
+        nativeObserver = Application.ios.addNotificationObserver(voiceOverStatusChangedNotificationName, () => {
+            setA11yEnabled(isVoiceOverRunning());
+        });
+        Application.on(Application.exitEvent, () => {
+            if (nativeObserver) {
+                Application.ios.removeNotificationObserver(nativeObserver, voiceOverStatusChangedNotificationName);
+            }
+            setA11yEnabled(undefined);
+            nativeObserver = null;
+        });
+    }
+    Application.on(Application.resumeEvent, () => {
+        setA11yEnabled(isVoiceOverRunning());
+    });
+    return isA11yEnabled();
+}
+export function getAndroidAccessibilityManager() {
+    return null;
+}
+let sharedA11YObservable;
+let nativeObserver;
+function getSharedA11YObservable() {
+    if (sharedA11YObservable) {
+        return sharedA11YObservable;
+    }
+    sharedA11YObservable = new SharedA11YObservable();
+    let isVoiceOverRunning;
+    if (typeof UIAccessibilityIsVoiceOverRunning === 'function') {
+        isVoiceOverRunning = UIAccessibilityIsVoiceOverRunning;
+    }
+    else {
+        if (typeof UIAccessibilityIsVoiceOverRunning !== 'function') {
+            Trace.write(`UIAccessibilityIsVoiceOverRunning() - is not a function`, Trace.categories.Accessibility, Trace.messageType.error);
+            isVoiceOverRunning = () => false;
+        }
+    }
+    sharedA11YObservable.set(AccessibilityServiceEnabledPropName, isVoiceOverRunning());
+    let voiceOverStatusChangedNotificationName = null;
+    if (typeof UIAccessibilityVoiceOverStatusDidChangeNotification !== 'undefined') {
+        // iOS 11+
+        voiceOverStatusChangedNotificationName = UIAccessibilityVoiceOverStatusDidChangeNotification;
+    }
+    else if (typeof UIAccessibilityVoiceOverStatusChanged !== 'undefined') {
+        // iOS <11
+        voiceOverStatusChangedNotificationName = UIAccessibilityVoiceOverStatusChanged;
+    }
+    if (voiceOverStatusChangedNotificationName) {
+        nativeObserver = Application.ios.addNotificationObserver(voiceOverStatusChangedNotificationName, () => {
+            sharedA11YObservable?.set(AccessibilityServiceEnabledPropName, isVoiceOverRunning());
+        });
+        Application.on(Application.exitEvent, () => {
+            if (nativeObserver) {
+                Application.ios.removeNotificationObserver(nativeObserver, voiceOverStatusChangedNotificationName);
+            }
+            nativeObserver = null;
+            if (sharedA11YObservable) {
+                sharedA11YObservable.removeEventListener(Observable.propertyChangeEvent);
+                sharedA11YObservable = null;
+            }
+        });
+    }
+    Application.on(Application.resumeEvent, () => sharedA11YObservable.set(AccessibilityServiceEnabledPropName, isVoiceOverRunning()));
+    return sharedA11YObservable;
+}
+export class AccessibilityServiceEnabledObservable extends CommonA11YServiceEnabledObservable {
+    constructor() {
+        super(getSharedA11YObservable());
+    }
+}
+let accessibilityServiceObservable;
+export function ensureClasses() {
+    if (accessibilityServiceObservable) {
+        return;
+    }
+    setFontScaleCssClasses(new Map(VALID_FONT_SCALES.map((fs) => [fs, `a11y-fontscale-${Number(fs * 100).toFixed(0)}`])));
+    accessibilityServiceObservable = new AccessibilityServiceEnabledObservable();
+    // Initialize SDK version CSS class once
+    initializeSdkVersionClass(Application.getRootView());
+}
+export function updateCurrentHelperClasses(applyRootCssClass) {
+    const fontScale = getFontScale();
+    const fontScaleCategory = getFontScaleCategory();
+    const fontScaleCssClasses = getFontScaleCssClasses();
+    const oldFontScaleClass = getCurrentFontScaleClass();
+    if (fontScaleCssClasses.has(fontScale)) {
+        setCurrentFontScaleClass(fontScaleCssClasses.get(fontScale));
+    }
+    else {
+        setCurrentFontScaleClass(fontScaleCssClasses.get(1));
+    }
+    if (oldFontScaleClass !== getCurrentFontScaleClass()) {
+        applyRootCssClass([...fontScaleCssClasses.values()], getCurrentFontScaleClass());
+    }
+    const oldActiveFontScaleCategory = getCurrentFontScaleCategory();
+    switch (fontScaleCategory) {
+        case FontScaleCategory.ExtraSmall: {
+            setCurrentFontScaleCategory(fontScaleExtraSmallCategoryClass);
+            break;
+        }
+        case FontScaleCategory.Medium: {
+            setCurrentFontScaleCategory(fontScaleMediumCategoryClass);
+            break;
+        }
+        case FontScaleCategory.ExtraLarge: {
+            setCurrentFontScaleCategory(fontScaleExtraLargeCategoryClass);
+            break;
+        }
+        default: {
+            setCurrentFontScaleCategory(fontScaleMediumCategoryClass);
+            break;
+        }
+    }
+    if (oldActiveFontScaleCategory !== getCurrentFontScaleCategory()) {
+        applyRootCssClass(fontScaleCategoryClasses, getCurrentFontScaleCategory());
+    }
+    const oldA11YStatusClass = getCurrentA11YServiceClass();
+    if (accessibilityServiceObservable.accessibilityServiceEnabled) {
+        setCurrentA11YServiceClass(a11yServiceEnabledClass);
+    }
+    else {
+        setCurrentA11YServiceClass(a11yServiceDisabledClass);
+    }
+    if (oldA11YStatusClass !== getCurrentA11YServiceClass()) {
+        applyRootCssClass(a11yServiceClasses, getCurrentA11YServiceClass());
+    }
+}
+function applyRootCssClass(cssClasses, newCssClass) {
+    const rootView = Application.getRootView();
+    if (!rootView) {
+        return;
+    }
+    Application.applyCssClass(rootView, cssClasses, newCssClass);
+    const rootModalViews = rootView._getRootModalViews();
+    rootModalViews.forEach((rootModalView) => Application.applyCssClass(rootModalView, cssClasses, newCssClass));
+}
+function applyFontScaleToRootViews() {
+    const rootView = Application.getRootView();
+    if (!rootView) {
+        return;
+    }
+    const fontScale = getCurrentFontScale();
+    rootView.style.fontScaleInternal = fontScale;
+    const rootModalViews = rootView._getRootModalViews();
+    rootModalViews.forEach((rootModalView) => (rootModalView.style.fontScaleInternal = fontScale));
+}
+export function initAccessibilityCssHelper() {
+    ensureClasses();
+    Application.on(Application.fontScaleChangedEvent, () => {
+        updateCurrentHelperClasses(applyRootCssClass);
+        applyFontScaleToRootViews();
+    });
+    accessibilityServiceObservable.on(AccessibilityServiceEnabledObservable.propertyChangeEvent, () => updateCurrentHelperClasses(applyRootCssClass));
+}
+setInitAccessibilityCssHelper(initAccessibilityCssHelper);
+const applicationEvents = [Application.orientationChangedEvent, Application.systemAppearanceChangedEvent];
+function toggleApplicationEventListeners(toAdd, callback) {
+    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(),
+    };
+});
 //# sourceMappingURL=application.ios.js.map