uicore-ts 1.0.237 → 1.0.251

package/compiledScripts/UIView.d.ts

@@ -299,14 +299,14 @@ export declare class UIView extends UIObject {
         maxCornerSize?: string;
         viewDidChangeToSize?: (view: UIView, isMovementCompleted: boolean) => void;
     }): void;
-    static shouldCallPointerUpInsideOnView(view: UIView): Promise<boolean>;
-    static shouldCallPointerHoverOnView(view: UIView): Promise<boolean>;
-    static shouldCallPointerLeaveOnView(view: UIView): Promise<boolean>;
-    static shouldCallPointerCancelOnView(view: UIView): Promise<boolean>;
-    shouldCallPointerUpInside(): Promise<boolean>;
-    shouldCallPointerCancel(): Promise<boolean>;
-    shouldCallPointerHover(): Promise<boolean>;
-    shouldCallPointerLeave(): Promise<boolean>;
+    static shouldCallPointerUpInsideOnView(view: UIView, event: MouseEvent | TouchEvent): Promise<boolean>;
+    static shouldCallPointerHoverOnView(view: UIView, event: MouseEvent | TouchEvent): Promise<boolean>;
+    static shouldCallPointerLeaveOnView(view: UIView, event: MouseEvent | TouchEvent): Promise<boolean>;
+    static shouldCallPointerCancelOnView(view: UIView, event: MouseEvent | TouchEvent): Promise<boolean>;
+    shouldCallPointerUpInside(event: MouseEvent | TouchEvent): Promise<boolean>;
+    shouldCallPointerCancel(event: MouseEvent | TouchEvent): Promise<boolean>;
+    shouldCallPointerHover(event: MouseEvent | TouchEvent): Promise<boolean>;
+    shouldCallPointerLeave(event: MouseEvent | TouchEvent): Promise<boolean>;
     protected _loadUIEvents(): void;
     static controlEvent: {
         PointerDown: string;

package/compiledScripts/UIView.js

@@ -55,6 +55,7 @@ var import_UICoreExtensions = require("./UICoreExtensions");
 var import_UIObject = require("./UIObject");
 var import_UIPoint = require("./UIPoint");
 var import_UIRectangle = require("./UIRectangle");
+var import_UIViewController = require("./UIViewController");
 if (!window.AutoLayout) {
   window.AutoLayout = import_UIObject.nil;
 }
@@ -270,17 +271,69 @@ const _UIView = class extends import_UIObject.UIObject {
   }
   get propertyDescriptors() {
     let result = [];
+    function isPlainObject(value) {
+      return value instanceof Object && Object.getPrototypeOf(value) === Object.prototype;
+    }
+    function isAnArray(value) {
+      return value instanceof Array && Object.getPrototypeOf(value) === Array.prototype;
+    }
     this.withAllSuperviews.forEach((view) => {
-      (0, import_UIObject.FIRST_OR_NIL)(view.viewController).forEach((value, key, stopLooping) => {
-        if (this == value) {
-          result.push({ object: view.viewController, name: key });
+      const descriptorFromObject = function(object, pathRootObject = object, existingPathComponents = [], lookInArrays = import_UIObject.YES, depthLeft = 5) {
+        var _a, _b;
+        let resultDescriptor;
+        const subObjects = [];
+        const subArrays = [];
+        (0, import_UIObject.FIRST_OR_NIL)(object).forEach((value, key, stopLooping) => {
+          if (this == value) {
+            existingPathComponents.push(key);
+            resultDescriptor = { object: pathRootObject, name: existingPathComponents.join(".") };
+            stopLooping();
+            return;
+          }
+          if (isPlainObject(value) && !_UIViewPropertyKeys.contains(key) && !_UIViewControllerPropertyKeys.contains(key)) {
+            subObjects.push({ object: value, key });
+          }
+          if (lookInArrays && isAnArray(value) && !_UIViewPropertyKeys.contains(key) && !_UIViewControllerPropertyKeys.contains(key)) {
+            subArrays.push({ array: value, key });
+          }
+        });
+        if (!resultDescriptor && lookInArrays) {
+          subArrays.copy().forEach((value) => {
+            if (value.key.startsWith("_")) {
+              subArrays.removeElement(value);
+              subArrays.push(value);
+            }
+          });
+          subArrays.find(
+            (arrayObject) => arrayObject.array.find((value, index) => {
+              if (this == value) {
+                existingPathComponents.push(arrayObject.key + "." + index);
+                resultDescriptor = { object: pathRootObject, name: existingPathComponents.join(".") };
+                return import_UIObject.YES;
+              }
+              return import_UIObject.NO;
+            })
+          );
         }
-      });
-      view.forEach((value, key, stopLooping) => {
-        if (this == value) {
-          result.push({ object: view, name: key });
+        if (((_b = (_a = resultDescriptor == null ? void 0 : resultDescriptor.object) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name) == "Object") {
+          var asd = 1;
         }
-      });
+        const result2 = {
+          descriptor: resultDescriptor,
+          subObjects
+        };
+        return result2;
+      }.bind(this);
+      const viewControllerResult = descriptorFromObject(view.viewController);
+      if (viewControllerResult == null ? void 0 : viewControllerResult.descriptor) {
+        result.push(viewControllerResult.descriptor);
+      }
+      const viewResult = descriptorFromObject(view);
+      if (viewResult == null ? void 0 : viewResult.descriptor) {
+        result.push(viewResult.descriptor);
+      } else if (this.superview && this.superview == view) {
+        result.push({ object: view, key: "subviews." + view.subviews.indexOf(this) });
+      }
     });
     return result;
   }
@@ -1167,8 +1220,9 @@ const _UIView = class extends import_UIObject.UIObject {
     };
     const PointerXDragFunction = (centeredOnPosition, sender, event) => {
       if (event instanceof MouseEvent) {
+        const scaleX = this.viewHTMLElement.getBoundingClientRect().width / this.viewHTMLElement.offsetWidth;
         const signMultiplier = 1 - 2 * centeredOnPosition;
-        let movementX = event.movementX;
+        let movementX = event.movementX / scaleX;
         if (xOverflow * signMultiplier > 0 && 0 > movementX) {
           xOverflow = (xOverflow + movementX / _UIView.pageScale).integerValue;
           if (xOverflow >= 0) {
@@ -1208,8 +1262,9 @@ const _UIView = class extends import_UIObject.UIObject {
     };
     const PointerYDragFunction = (centeredOnPosition, sender, event) => {
       if (event instanceof MouseEvent) {
+        const scaleX = this.viewHTMLElement.getBoundingClientRect().width / this.viewHTMLElement.offsetWidth;
         const signMultiplier = 1 - 2 * centeredOnPosition;
-        let movementY = event.movementY;
+        let movementY = event.movementY / scaleX;
         if (yOverflow * signMultiplier > 0 && 0 > movementY) {
           yOverflow = (yOverflow + movementY / _UIView.pageScale).integerValue;
           if (yOverflow >= 0) {
@@ -1584,37 +1639,37 @@ const _UIView = class extends import_UIObject.UIObject {
       this._isResizable = import_UIObject.NO;
     };
   }
-  static shouldCallPointerUpInsideOnView(view) {
+  static shouldCallPointerUpInsideOnView(view, event) {
     return __async(this, null, function* () {
       return import_UIObject.YES;
     });
   }
-  static shouldCallPointerHoverOnView(view) {
+  static shouldCallPointerHoverOnView(view, event) {
     return __async(this, null, function* () {
       return import_UIObject.YES;
     });
   }
-  static shouldCallPointerLeaveOnView(view) {
+  static shouldCallPointerLeaveOnView(view, event) {
     return __async(this, null, function* () {
       return import_UIObject.YES;
     });
   }
-  static shouldCallPointerCancelOnView(view) {
+  static shouldCallPointerCancelOnView(view, event) {
     return __async(this, null, function* () {
       return import_UIObject.YES;
     });
   }
-  shouldCallPointerUpInside() {
-    return _UIView.shouldCallPointerUpInsideOnView(this);
+  shouldCallPointerUpInside(event) {
+    return _UIView.shouldCallPointerUpInsideOnView(this, event);
   }
-  shouldCallPointerCancel() {
-    return _UIView.shouldCallPointerCancelOnView(this);
+  shouldCallPointerCancel(event) {
+    return _UIView.shouldCallPointerCancelOnView(this, event);
   }
-  shouldCallPointerHover() {
-    return _UIView.shouldCallPointerHoverOnView(this);
+  shouldCallPointerHover(event) {
+    return _UIView.shouldCallPointerHoverOnView(this, event);
   }
-  shouldCallPointerLeave() {
-    return _UIView.shouldCallPointerLeaveOnView(this);
+  shouldCallPointerLeave(event) {
+    return _UIView.shouldCallPointerLeaveOnView(this, event);
   }
   _loadUIEvents() {
     const isTouchEventClassDefined = import_UIObject.NO || window.TouchEvent;
@@ -1669,7 +1724,7 @@ const _UIView = class extends import_UIObject.UIObject {
       if (this.ignoresTouches && isTouchEventClassDefined && event instanceof TouchEvent || this.ignoresMouse && event instanceof MouseEvent) {
         return;
       }
-      if (this._isPointerInside && (yield this.shouldCallPointerUpInside())) {
+      if (this._isPointerInside && (yield this.shouldCallPointerUpInside(event))) {
         onPointerUpInside(event);
         if (!this._hasPointerDragged) {
           this.sendControlEventForKey(_UIView.controlEvent.PointerTap, event);
@@ -1683,7 +1738,7 @@ const _UIView = class extends import_UIObject.UIObject {
       if (this.ignoresTouches && isTouchEventClassDefined && event instanceof TouchEvent || this.ignoresMouse && event instanceof MouseEvent) {
         return;
       }
-      if (yield this.shouldCallPointerLeave()) {
+      if (yield this.shouldCallPointerLeave(event)) {
         this.sendControlEventForKey(_UIView.controlEvent.PointerLeave, event);
       }
       this._isPointerInside = import_UIObject.NO;
@@ -1694,7 +1749,7 @@ const _UIView = class extends import_UIObject.UIObject {
       if (this.ignoresTouches && isTouchEventClassDefined && event instanceof TouchEvent || this.ignoresMouse && event instanceof MouseEvent) {
         return;
       }
-      if (yield this.shouldCallPointerHover()) {
+      if (yield this.shouldCallPointerHover(event)) {
         this.sendControlEventForKey(_UIView.controlEvent.PointerHover, event);
       }
       this._isPointerInside = import_UIObject.YES;
@@ -1752,7 +1807,7 @@ const _UIView = class extends import_UIObject.UIObject {
       }
       if (this._isPointerInside && this.viewHTMLElement != document.elementFromPoint(touch.clientX, touch.clientY)) {
         this._isPointerInside = import_UIObject.NO;
-        if (yield this.shouldCallPointerLeave()) {
+        if (yield this.shouldCallPointerLeave(event)) {
           this.sendControlEventForKey(_UIView.controlEvent.PointerLeave, event);
         }
       }
@@ -1783,7 +1838,7 @@ const _UIView = class extends import_UIObject.UIObject {
       this._isPointerValid = import_UIObject.NO;
       this._isPointerValidForMovement = import_UIObject.NO;
       this._isPointerDown = import_UIObject.NO;
-      if (yield this.shouldCallPointerCancel()) {
+      if (yield this.shouldCallPointerCancel(event)) {
         this.sendControlEventForKey(_UIView.controlEvent.PointerCancel, event);
       }
     });
@@ -2109,6 +2164,20 @@ const windowTouchFunction = () => {
 };
 window.addEventListener("touchmove", UIView._onWindowTouchMove, true);
 window.addEventListener("mouseup", windowTouchFunction, true);
+function props(obj) {
+  const p = [];
+  for (; obj != null; obj = Object.getPrototypeOf(obj)) {
+    const op = Object.getOwnPropertyNames(obj);
+    for (let i = 0; i < op.length; i++) {
+      if (p.indexOf(op[i]) == -1) {
+        p.push(op[i]);
+      }
+    }
+  }
+  return p;
+}
+const _UIViewPropertyKeys = props(UIView.prototype).concat(new UIView().allKeys);
+const _UIViewControllerPropertyKeys = props(import_UIViewController.UIViewController.prototype).concat(new import_UIViewController.UIViewController(import_UIObject.nil).allKeys);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   UIView