native-fn 1.3.0 → 1.3.2

package/dist/plugin/dimension/index.mjs

@@ -17,9 +17,20 @@ var FALLBACK_MEDIA_QUERY_LIST = {
 
 var Orientation;
 (function (Orientation) {
-    Orientation["Portrait"] = "portrait";
-    Orientation["Landscape"] = "landscape";
-    Orientation["Unknown"] = "unknown";
+    Orientation["PortraitPrimary"] = "portrait-primary";
+    Orientation["PortraitSecondary"] = "portrait-secondary";
+    Orientation["LandscapePrimary"] = "landscape-primary";
+    Orientation["LandscapeSecondary"] = "landscape-secondary";
+})(Orientation || (Orientation = {}));
+(function (Orientation) {
+    function isLandscape(orientation) {
+        return orientation === Orientation.LandscapePrimary || orientation === Orientation.LandscapeSecondary;
+    }
+    Orientation.isLandscape = isLandscape;
+    function isPortrait(orientation) {
+        return orientation === Orientation.PortraitPrimary || orientation === Orientation.PortraitSecondary;
+    }
+    Orientation.isPortrait = isPortrait;
 })(Orientation || (Orientation = {}));
 var ENV_PRESETS = {
     'safe-area-inset': {
@@ -471,7 +482,6 @@ function createViewportSegmentObserver() {
     var segmentMediaQueryLists = [];
     var previousSegments = null;
     function attachCSSFallbackListeners() {
-        EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
         segmentMediaQueryLists = buildSegmentMediaQueryLists();
         for (var i = 0; i < segmentMediaQueryLists.length; i++)
             EventListener.add(segmentMediaQueryLists[i], { type: 'change', callback: onSegmentChange });
@@ -479,50 +489,53 @@ function createViewportSegmentObserver() {
             EventListener.add(DEVICE_POSTURE_MEDIA_QUERY_LIST, { type: 'change', callback: onSegmentChange });
     }
     function detachCSSFallbackListeners() {
-        EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
         for (var i = 0; i < segmentMediaQueryLists.length; i++)
             EventListener.remove(segmentMediaQueryLists[i], { type: 'change', callback: onSegmentChange });
         segmentMediaQueryLists = [];
         if (DEVICE_POSTURE_MEDIA_QUERY_LIST.media !== 'not all')
             EventListener.remove(DEVICE_POSTURE_MEDIA_QUERY_LIST, { type: 'change', callback: onSegmentChange });
     }
+    function attachDevicePostureChangeListener() {
+        if (hasDevicePosture)
+            EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
+        attachCSSFallbackListeners();
+    }
+    function detachDevicePostureChangeListener() {
+        if (hasDevicePosture)
+            EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
+        detachCSSFallbackListeners();
+    }
+    function attachVisualViewportResizeListener() {
+        EventListener.add(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
+    }
+    function detachVisualViewportResizeListener() {
+        EventListener.remove(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
+    }
     function attachOnChange() {
+        EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
         if (hasSegmentsAPI) {
-            if (hasDevicePosture) {
-                EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
-                EventListener.add(globalThis, { type: 'resize', callback: onSegmentChange });
-            }
-            else {
-                attachCSSFallbackListeners();
-            }
+            attachDevicePostureChangeListener();
         }
         else if (hasLegacySegmentsAPI) {
-            EventListener.add(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
-            if (hasSegmentsAPI)
-                EventListener.add(devicePosture, { type: 'change', callback: onSegmentChange });
+            attachVisualViewportResizeListener();
+            attachDevicePostureChangeListener();
         }
         else {
             getOrCreateCachedDiv();
-            attachCSSFallbackListeners();
+            attachVisualViewportResizeListener();
         }
     }
     function detachOnChange() {
+        EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
         if (hasSegmentsAPI) {
-            if (hasDevicePosture) {
-                EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
-                EventListener.remove(globalThis, { type: 'resize', callback: onSegmentChange });
-            }
-            else {
-                detachCSSFallbackListeners();
-            }
+            detachDevicePostureChangeListener();
         }
         else if (hasLegacySegmentsAPI) {
-            EventListener.remove(visualViewport, { type: 'resize', callback: onSegmentChange, options: { passive: true } });
-            if (hasSegmentsAPI)
-                EventListener.remove(devicePosture, { type: 'change', callback: onSegmentChange });
+            detachVisualViewportResizeListener();
+            detachDevicePostureChangeListener();
         }
         else {
-            detachCSSFallbackListeners();
+            detachVisualViewportResizeListener();
             releaseDiv();
         }
     }
@@ -674,7 +687,7 @@ function createViewportSegmentObserver() {
         function applySegments(segments) {
             for (var i = segments.length; i < lastCount; i++) {
                 for (var j = 0; j < attributes.length; j++) {
-                    element.style.removeProperty("--".concat(prefix, "-").concat(i, "-").concat(attributes[j]));
+                    element.style.removeProperty('--' + prefix + '-' + i + '-' + attributes[j]);
                 }
             }
             lastCount = segments.length;
@@ -682,7 +695,7 @@ function createViewportSegmentObserver() {
                 var segment = segments[i];
                 for (var j = 0; j < attributes.length; j++) {
                     var attribute = attributes[j];
-                    element.style.setProperty("--".concat(prefix, "-").concat(i, "-").concat(attribute), segment[attribute] + 'px');
+                    element.style.setProperty('--' + prefix + '-' + i + '-' + attribute, segment[attribute] + 'px');
                 }
             }
         }
@@ -694,7 +707,7 @@ function createViewportSegmentObserver() {
             unsubscribe();
             for (var i = 0; i < lastCount; i++)
                 for (var j = 0; j < attributes.length; j++)
-                    element.style.removeProperty("--".concat(prefix, "-").concat(i, "-").concat(attributes[j]));
+                    element.style.removeProperty('--' + prefix + '-' + i + '-' + attributes[j]);
             lastCount = 0;
         };
     }
@@ -708,15 +721,11 @@ function createViewportSegmentObserver() {
 }
 function createVirtualKeyboardObserver() {
     var onChangeSubscriptionManager = createSubscriptionManager(attachOnChange, detachOnChange);
-    var previousOverlaysContent = false;
     function attachOnChange() {
-        previousOverlaysContent = globalThis.navigator.virtualKeyboard.overlaysContent;
-        globalThis.navigator.virtualKeyboard.overlaysContent = true;
         EventListener.add(globalThis.navigator.virtualKeyboard, { type: 'geometrychange', callback: onGeometryChange, options: { passive: true } });
     }
     function detachOnChange() {
         EventListener.remove(globalThis.navigator.virtualKeyboard, { type: 'geometrychange', callback: onGeometryChange, options: { passive: true } });
-        globalThis.navigator.virtualKeyboard.overlaysContent = previousOverlaysContent;
     }
     function onGeometryChange() {
         onChangeSubscriptionManager.emit(getValue());
@@ -754,7 +763,7 @@ function createVirtualKeyboardObserver() {
         function applyValues(values) {
             for (var i = 0; i < attributes.length; i++) {
                 var attribute = attributes[i];
-                element.style.setProperty("--".concat(prefix, "-").concat(attribute), values[attribute] + 'px');
+                element.style.setProperty('--' + prefix + '-' + attribute, values[attribute] + 'px');
             }
         }
         applyValues(getValue());
@@ -764,7 +773,7 @@ function createVirtualKeyboardObserver() {
         return function () {
             unsubscribe();
             for (var i = 0; i < attributes.length; i++)
-                element.style.removeProperty("--".concat(prefix, "-").concat(attributes[i]));
+                element.style.removeProperty('--' + prefix + '-' + attributes[i]);
         };
     }
     return {
@@ -953,7 +962,7 @@ function createEnvironmentObserver(preset) {
         function applyValues(values) {
             for (var i = 0; i < attributes.length; i++) {
                 var attribute = attributes[i];
-                element.style.setProperty("--".concat(prefix, "-").concat(String(attribute)), values[attribute] + 'px');
+                element.style.setProperty('--' + prefix + '-' + String(attributes[i]), values[attribute] + 'px');
             }
         }
         var unsubscribe = onChangeSubscriptionManager.subscribe(function (values) {
@@ -963,7 +972,7 @@ function createEnvironmentObserver(preset) {
         return function () {
             unsubscribe();
             for (var i = 0; i < attributes.length; i++)
-                element.style.removeProperty("--".concat(prefix, "-").concat(String(attributes[i])));
+                element.style.removeProperty('--' + prefix + '-' + String(attributes[i]));
         };
     }
     return {
@@ -985,51 +994,151 @@ function createEnvironmentObserver(preset) {
     };
 }
 
+function createCustomError(name, Base) {
+    if (Base === void 0) { Base = Error; }
+    function CustomError(message) {
+        if (!(this instanceof CustomError))
+            return new CustomError(message);
+        var error = (function () {
+            if (typeof message === 'undefined')
+                return new Base('');
+            return new Base(message);
+        })();
+        if (typeof Object.setPrototypeOf === 'function')
+            Object.setPrototypeOf(error, CustomError.prototype);
+        else
+            error.__proto__ = CustomError.prototype;
+        error.name = name;
+        if (typeof message !== 'undefined')
+            error.message = message;
+        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            try {
+                Object.defineProperty(error, Symbol.toStringTag, {
+                    value: name,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (_) {
+            }
+        }
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(error, CustomError);
+        }
+        else if (Base.captureStackTrace && typeof Base.captureStackTrace === 'function') {
+            Base.captureStackTrace(error, CustomError);
+        }
+        else {
+            try {
+                var tempError = new Base();
+                if (tempError.stack)
+                    error.stack = tempError.stack;
+            }
+            catch (_) {
+            }
+        }
+        return error;
+    }
+    CustomError.prototype = Object.create(Base.prototype, {
+        constructor: {
+            value: CustomError,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    try {
+        Object.defineProperty(CustomError.prototype, 'name', {
+            value: name,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+        try {
+            CustomError.prototype.name = name;
+        }
+        catch (_) {
+        }
+    }
+    try {
+        Object.defineProperty(CustomError, 'name', {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+    }
+    return CustomError;
+}
+
+var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
+
+var NotSupportedError = createCustomError('NotSupportedError');
+
 var safeAreaInsetObserver = createEnvironmentObserver('safe-area-inset');
 var safeAreaMaxInsetObserver = createEnvironmentObserver('safe-area-max-inset');
 var keyboardInsetObserver = createEnvironmentObserver('keyboard-inset');
 var titlebarAreaObserver = createEnvironmentObserver('titlebar-area');
 var viewportSegmentObserver = createEnvironmentObserver('viewport-segment');
-var onChangeSubscriptionManager = createSubscriptionManager(attachOnChange, detachOnChange);
+var onDimensionChangeSubscriptionManager = createSubscriptionManager(attachOnDimensionChange, detachOnDimensionChange);
+var onScreenOrientationChangeSubscriptionManager = createSubscriptionManager(attachOnScreenOrientationChange, detachOnScreenOrientationChange);
+var onDeviceOrientationChangeSubscriptionManager = createSubscriptionManager(attachOnDeviceOrientationChange, detachOnDeviceOrientationChange);
 var dimensionRef = null;
+var screenOrientationRef = null;
+var deviceOrientationRef = null;
 var Dimension = {
     get value() {
         return getDimension();
     },
     environment: getEnvironment(),
-    onChange: onChangeSubscriptionManager.subscribe,
+    screenOrientation: getScreenOrientation(),
+    deviceOrientation: getDeviceOrientation(),
+    onChange: onDimensionChangeSubscriptionManager.subscribe,
     Constants: {
         Orientation: Orientation,
     },
-    Errors: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+        PermissionNotGrantedError: PermissionNotGrantedError,
+    },
 };
 function getOrientation() {
-    if (typeof globalThis.screen !== 'undefined') {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.type !== 'undefined') {
         switch (globalThis.screen.orientation.type) {
             case 'portrait-primary':
+                return Orientation.PortraitPrimary;
             case 'portrait-secondary':
-                return Orientation.Portrait;
+                return Orientation.PortraitSecondary;
             case 'landscape-primary':
+                return Orientation.LandscapePrimary;
             case 'landscape-secondary':
-                return Orientation.Landscape;
+                return Orientation.LandscapeSecondary;
         }
     }
     if (typeof globalThis.orientation !== 'undefined') {
         switch (globalThis.orientation) {
             case 0:
+                return Orientation.PortraitPrimary;
             case 180:
-                return Orientation.Portrait;
+                return Orientation.PortraitSecondary;
             case 90:
+                return Orientation.LandscapePrimary;
+            case -90:
             case 270:
-                return Orientation.Landscape;
+                return Orientation.LandscapeSecondary;
         }
     }
     if (ORIENTATION_MEDIA_QUERY_LIST.media === 'not all')
-        return Orientation.Unknown;
-    else if (ORIENTATION_MEDIA_QUERY_LIST.matches)
-        return Orientation.Portrait;
+        throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
+    if (ORIENTATION_MEDIA_QUERY_LIST.matches)
+        return Orientation.PortraitPrimary;
     else
-        return Orientation.Landscape;
+        return Orientation.LandscapePrimary;
 }
 function getScale() {
     if (typeof globalThis.devicePixelRatio !== 'undefined')
@@ -1045,47 +1154,168 @@ function getEnvironment() {
         viewportSegment: viewportSegmentObserver,
     };
 }
-function getDimension() {
-    var dimensions = {
-        innerWidth: 0,
-        innerHeight: 0,
-        outerWidth: 0,
-        outerHeight: 0,
-        scale: getScale(),
-        orientation: getOrientation(),
+function getScreenOrientation() {
+    return {
+        get supported() {
+            return screenOrientationSupported();
+        },
+        get value() {
+            return getOrientation();
+        },
+        onChange: onScreenOrientationChangeSubscriptionManager.subscribe,
     };
+}
+function getDeviceOrientation() {
+    return {
+        get supported() {
+            return deviceOrientationSupported();
+        },
+        get value() {
+            return getDeviceOrientationValue();
+        },
+        onChange: onDeviceOrientationChangeSubscriptionManager.subscribe,
+    };
+}
+function getDimension() {
+    var innerWidth = 0;
+    var innerHeight = 0;
+    var outerWidth = 0;
+    var outerHeight = 0;
+    var scale = getScale();
     if (typeof globalThis.innerWidth !== 'undefined') {
-        dimensions.innerWidth = globalThis.innerWidth;
-        dimensions.innerHeight = globalThis.innerHeight;
-        dimensions.outerWidth = globalThis.outerWidth;
-        dimensions.outerHeight = globalThis.outerHeight;
+        innerWidth = globalThis.innerWidth;
+        innerHeight = globalThis.innerHeight;
+        outerWidth = globalThis.outerWidth;
+        outerHeight = globalThis.outerHeight;
     }
-    return dimensions;
+    return {
+        innerWidth: innerWidth,
+        innerHeight: innerHeight,
+        outerWidth: outerWidth,
+        outerHeight: outerHeight,
+        scale: scale,
+    };
 }
-function attachOnChange() {
+function attachOnDimensionChange() {
     dimensionRef = getDimension();
-    EventListener.add(globalThis, { type: 'resize', callback: onResize });
-    if (typeof globalThis.screen.orientation.addEventListener === 'function')
-        EventListener.add(globalThis.screen.orientation, { type: 'change', callback: onResize });
+    EventListener.add(globalThis, { type: 'resize', callback: onDimensionChange });
+}
+function detachOnDimensionChange() {
+    dimensionRef = null;
+    EventListener.remove(globalThis, { type: 'resize', callback: onDimensionChange });
+}
+function onDimensionChange() {
+    var dimension = getDimension();
+    if (dimensionRef === null || dimension.innerWidth !== dimensionRef.innerWidth || dimension.innerHeight !== dimensionRef.innerHeight || dimension.outerWidth !== dimensionRef.outerWidth || dimension.outerHeight !== dimensionRef.outerHeight || dimension.scale !== dimensionRef.scale)
+        onDimensionChangeSubscriptionManager.emit(dimensionRef = dimension);
+}
+function screenOrientationSupported() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.type !== 'undefined')
+        return true;
+    if (typeof globalThis.orientation !== 'undefined')
+        return true;
+    return ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all';
+}
+function attachOnScreenOrientationChange() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.addEventListener === 'function')
+        return EventListener.add(globalThis.screen.orientation, {
+            type: 'change',
+            callback: onScreenOrientationChange
+        });
     else if (typeof globalThis.orientation !== 'undefined')
-        EventListener.add(globalThis, { type: 'orientationChange', callback: onResize });
+        return EventListener.add(globalThis, { type: 'orientationchange', callback: onScreenOrientationChange });
     else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
-        EventListener.add(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onResize });
+        return EventListener.add(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onScreenOrientationChange });
+    throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
 }
-function detachOnChange() {
-    dimensionRef = null;
-    EventListener.remove(globalThis, { type: 'resize', callback: onResize });
-    if (typeof globalThis.screen.orientation.removeEventListener === 'function')
-        EventListener.remove(globalThis.screen.orientation, { type: 'change', callback: onResize });
+function detachOnScreenOrientationChange() {
+    if (typeof globalThis.screen !== 'undefined' && typeof globalThis.screen.orientation !== 'undefined' && typeof globalThis.screen.orientation.removeEventListener === 'function')
+        return EventListener.remove(globalThis.screen.orientation, {
+            type: 'change',
+            callback: onScreenOrientationChange
+        });
     else if (typeof globalThis.orientation !== 'undefined')
-        EventListener.remove(globalThis, { type: 'orientationChange', callback: onResize });
+        return EventListener.remove(globalThis, { type: 'orientationchange', callback: onScreenOrientationChange });
     else if (ORIENTATION_MEDIA_QUERY_LIST.media !== 'not all')
-        EventListener.remove(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onResize });
+        return EventListener.remove(ORIENTATION_MEDIA_QUERY_LIST, { type: 'change', callback: onScreenOrientationChange });
+    throw new NotSupportedError('\'screen.orientation\', \'window.orientation\', and the orientation media query are all unsupported');
 }
-function onResize() {
-    var dimension = getDimension();
-    if (dimensionRef === null || dimension.innerWidth !== dimensionRef.innerWidth || dimension.innerHeight !== dimensionRef.innerHeight || dimension.outerWidth !== dimensionRef.outerWidth || dimension.outerHeight !== dimensionRef.outerHeight || dimension.scale !== dimensionRef.scale || dimension.orientation !== dimensionRef.orientation)
-        onChangeSubscriptionManager.emit(dimensionRef = dimension);
+function onScreenOrientationChange() {
+    var orientation = getOrientation();
+    if (screenOrientationRef === null || orientation !== screenOrientationRef)
+        onScreenOrientationChangeSubscriptionManager.emit(screenOrientationRef = orientation);
+}
+function deviceOrientationSupported() {
+    return typeof globalThis.DeviceOrientationEvent !== 'undefined';
+}
+function attachOnDeviceOrientationChange() {
+    return new Promise(function (resolve, reject) {
+        if (!deviceOrientationSupported())
+            return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+        var DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+        if (typeof DeviceOrientationEventWithPermission.requestPermission === 'function') {
+            DeviceOrientationEventWithPermission.requestPermission().then(function (permission) {
+                if (permission === 'granted') {
+                    EventListener.add(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+                    return resolve();
+                }
+                return reject(new PermissionNotGrantedError('\'deviceorientation\' permission is not granted.'));
+            }).catch(function (_) {
+                return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+            });
+        }
+        else {
+            EventListener.add(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+            return resolve();
+        }
+    });
+}
+function detachOnDeviceOrientationChange() {
+    EventListener.remove(globalThis, { type: 'deviceorientation', callback: onDeviceOrientationChange });
+}
+function onDeviceOrientationChange(event) {
+    deviceOrientationRef = {
+        alpha: event.alpha,
+        beta: event.beta,
+        gamma: event.gamma,
+        absolute: event.absolute,
+    };
+    onDeviceOrientationChangeSubscriptionManager.emit(deviceOrientationRef);
+}
+function getDeviceOrientationValue() {
+    return new Promise(function (resolve, reject) {
+        if (deviceOrientationRef !== null)
+            return resolve(deviceOrientationRef);
+        if (!deviceOrientationSupported())
+            return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+        var DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+        var callback = function (event) {
+            var value = {
+                alpha: event.alpha,
+                beta: event.beta,
+                gamma: event.gamma,
+                absolute: event.absolute,
+            };
+            deviceOrientationRef = value;
+            EventListener.remove(globalThis, { type: 'deviceorientation', callback: callback });
+            return resolve(value);
+        };
+        if (typeof DeviceOrientationEventWithPermission.requestPermission === 'function') {
+            DeviceOrientationEventWithPermission.requestPermission().then(function (permission) {
+                if (permission === 'granted') {
+                    EventListener.add(globalThis, { type: 'deviceorientation', callback: callback });
+                    return;
+                }
+                return reject(new PermissionNotGrantedError('\'deviceorientation\' permission is not granted.'));
+            }).catch(function (_) {
+                return reject(new NotSupportedError('\'window.DeviceOrientationEvent\' does not supported.'));
+            });
+        }
+        else {
+            EventListener.add(globalThis, { type: 'deviceorientation', callback: callback });
+            return;
+        }
+    });
 }
 
 export { DEVICE_POSTURE_MEDIA_QUERY_LIST, ENV_PRESETS, ORIENTATION_MEDIA_QUERY_LIST, Orientation, Dimension as default };

package/dist/plugin/dimension/src/plugin/appearance/types/appearance.d.ts

@@ -2,8 +2,8 @@ import { Appearances } from "../constants";
 export declare interface AppearanceInstance {
     get value(): Appearances;
     onChange(listener: (appearance: Appearances) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Appearances: typeof Appearances;
+    readonly Constants: {
+        readonly Appearances: typeof Appearances;
     };
-    Errors: {};
+    readonly Errors: {};
 }

package/dist/plugin/dimension/src/plugin/badge/types/badge.d.ts

@@ -3,8 +3,8 @@ export declare interface BadgeInstance {
     get supported(): boolean;
     set(contents: number): Promise<void>;
     clear(): Promise<void>;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/dimension/src/plugin/battery/types/battery.d.ts

@@ -19,8 +19,8 @@ export declare interface BatteryInstance {
     get supported(): boolean;
     get value(): Promise<BatteryManager>;
     onChange(listener: (battery: BatteryManager) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/dimension/src/plugin/clipboard/types/clipboard.d.ts

@@ -1,6 +1,6 @@
 export declare interface ClipboardInstance {
     copy(item: any): Promise<boolean>;
     paste(): Promise<string>;
-    Constants: {};
-    Errors: {};
+    readonly Constants: {};
+    readonly Errors: {};
 }

package/dist/plugin/dimension/src/plugin/dimension/constants/index.d.ts

@@ -1,7 +1,12 @@
 export declare enum Orientation {
-    Portrait = "portrait",
-    Landscape = "landscape",
-    Unknown = "unknown"
+    PortraitPrimary = "portrait-primary",
+    PortraitSecondary = "portrait-secondary",
+    LandscapePrimary = "landscape-primary",
+    LandscapeSecondary = "landscape-secondary"
+}
+export declare namespace Orientation {
+    function isLandscape(orientation: Orientation): boolean;
+    function isPortrait(orientation: Orientation): boolean;
 }
 export declare const ENV_PRESETS: {
     readonly 'safe-area-inset': {