uicore-ts 1.1.88 → 1.1.102

package/compiledScripts/UIView.js

@@ -93,6 +93,7 @@ const _UIView = class extends import_UIObject.UIObject {
     this._isCBEditorTemporaryMovable = import_UIObject.NO;
     this._intrinsicSizesCache = {};
     this.usesVirtualLayoutingForIntrinsicSizing = import_UIObject.YES;
+    this._contentInsets = { top: 0, left: 0, bottom: 0, right: 0 };
     this.controlEvent = _UIView.controlEvent;
     _UIView._UIViewIndex = _UIView.nextIndex;
     this._UIViewIndex = _UIView._UIViewIndex;
@@ -104,24 +105,93 @@ const _UIView = class extends import_UIObject.UIObject {
     this._loadUIEvents();
     this.setNeedsLayout();
   }
+  static get isVirtualLayouting() {
+    return this._virtualLayoutingDepth > 0;
+  }
+  get isVirtualLayouting() {
+    return _UIView._virtualLayoutingDepth > 0;
+  }
+  startVirtualLayout() {
+    _UIView._virtualLayoutingDepth = _UIView._virtualLayoutingDepth + 1;
+  }
+  finishVirtualLayout() {
+    if (_UIView._virtualLayoutingDepth === 0) {
+      throw new Error("Unbalanced finishVirtualLayout()");
+    }
+    _UIView._virtualLayoutingDepth = _UIView._virtualLayoutingDepth - 1;
+  }
   static get nextIndex() {
     return _UIView._UIViewIndex + 1;
   }
-  static get pageHeight() {
+  static _initializePageDimensionsCacheIfNeeded() {
+    if (this._resizeObserverInitialized) {
+      return;
+    }
+    this._resizeObserverInitialized = true;
+    window.addEventListener("resize", () => {
+      this._pageDimensionsCacheValid = false;
+    }, { passive: true });
+    const bodyObserver = new ResizeObserver(() => {
+      this._pageDimensionsCacheValid = false;
+    });
+    if (document.body) {
+      bodyObserver.observe(document.body);
+    } else {
+      document.addEventListener("DOMContentLoaded", () => {
+        bodyObserver.observe(document.body);
+      }, { once: true });
+    }
+    const mutationObserver = new MutationObserver(() => {
+      this._pageDimensionsCacheValid = false;
+    });
+    const observeMutations = () => {
+      mutationObserver.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ["style", "class"]
+      });
+    };
+    if (document.body) {
+      observeMutations();
+    } else {
+      document.addEventListener("DOMContentLoaded", observeMutations, { once: true });
+    }
+  }
+  static _updatePageDimensionsCacheIfNeeded() {
+    if (this._pageDimensionsCacheValid && this._cachedPageWidth !== void 0 && this._cachedPageHeight !== void 0) {
+      return;
+    }
     const body = document.body;
     const html = document.documentElement;
-    return Math.max(
+    this._cachedPageWidth = Math.max(
+      body.scrollWidth,
+      body.offsetWidth,
+      html.clientWidth,
+      html.scrollWidth,
+      html.offsetWidth
+    );
+    this._cachedPageHeight = Math.max(
       body.scrollHeight,
       body.offsetHeight,
       html.clientHeight,
       html.scrollHeight,
       html.offsetHeight
     );
+    this._pageDimensionsCacheValid = true;
   }
   static get pageWidth() {
-    const body = document.body;
-    const html = document.documentElement;
-    return Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth);
+    this._initializePageDimensionsCacheIfNeeded();
+    this._updatePageDimensionsCacheIfNeeded();
+    return this._cachedPageWidth;
+  }
+  static get pageHeight() {
+    this._initializePageDimensionsCacheIfNeeded();
+    this._updatePageDimensionsCacheIfNeeded();
+    return this._cachedPageHeight;
+  }
+  static invalidatePageDimensionsCache() {
+    this._pageDimensionsCacheValid = false;
   }
   centerInContainer() {
     this.style.left = "50%";
@@ -470,7 +540,7 @@ const _UIView = class extends import_UIObject.UIObject {
   get frame() {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     let result;
-    if (!_UIView.isVirtualLayouting) {
+    if (!this.isVirtualLayouting) {
       result = (_a = this._frame) == null ? void 0 : _a.copy();
     } else {
       result = (_b = this._frameForVirtualLayouting) == null ? void 0 : _b.copy();
@@ -496,7 +566,7 @@ const _UIView = class extends import_UIObject.UIObject {
     if (zIndex != void 0) {
       rectangle.zIndex = zIndex;
     }
-    if (!_UIView.isVirtualLayouting) {
+    if (!this.isVirtualLayouting) {
       this._frame = rectangle;
     } else {
       this._frameForVirtualLayouting = rectangle;
@@ -509,7 +579,7 @@ const _UIView = class extends import_UIObject.UIObject {
     if (this.isInternalScaling) {
       rectangle.scale(1 / this.scale);
     }
-    if (!_UIView.isVirtualLayouting) {
+    if (!this.isVirtualLayouting) {
       _UIView._setAbsoluteSizeAndPosition(
         this.viewHTMLElement,
         rectangle.topLeft.x,
@@ -526,32 +596,35 @@ const _UIView = class extends import_UIObject.UIObject {
     }
   }
   get bounds() {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     let _frame;
-    if (!_UIView.isVirtualLayouting) {
+    if (!this.isVirtualLayouting) {
       _frame = this._frame;
     } else {
       _frame = this._frameForVirtualLayouting;
     }
     let result;
     if ((0, import_UIObject.IS_NOT)(_frame)) {
-      result = new import_UIRectangle.UIRectangle(
+      result = (_e = this._frameCache) != null ? _e : new import_UIRectangle.UIRectangle(
         0,
         0,
         (_b = (_a = this._resizeObserverEntry) == null ? void 0 : _a.contentRect.height) != null ? _b : this.viewHTMLElement.offsetHeight,
         (_d = (_c = this._resizeObserverEntry) == null ? void 0 : _c.contentRect.width) != null ? _d : this.viewHTMLElement.offsetWidth
       );
+      this._frameCache = result;
     } else {
       let frame;
-      if (!_UIView.isVirtualLayouting) {
+      if (!this.isVirtualLayouting) {
         frame = this.frame;
       } else {
-        frame = (_e = this._frameForVirtualLayouting) != null ? _e : this.frame;
+        frame = (_f = this._frameForVirtualLayouting) != null ? _f : this.frame;
       }
       result = frame.copy();
       result.x = 0;
       result.y = 0;
     }
+    result.minHeight = 0;
+    result.minWidth = 0;
     return result;
   }
   set bounds(rectangle) {
@@ -564,6 +637,7 @@ const _UIView = class extends import_UIObject.UIObject {
   }
   didResize(entry) {
     this._resizeObserverEntry = entry;
+    this._frameCache = void 0;
     this.setNeedsLayout();
     this.boundsDidChange(new import_UIRectangle.UIRectangle(0, 0, entry.contentRect.height, entry.contentRect.width));
   }
@@ -891,19 +965,42 @@ const _UIView = class extends import_UIObject.UIObject {
     _UIView.runFunctionBeforeNextFrame(_UIView.layoutViewsIfNeeded);
   }
   static layoutViewsIfNeeded() {
-    for (var i = 0; i < _UIView._viewsToLayout.length; i++) {
-      const view = _UIView._viewsToLayout[i];
-      view.layoutIfNeeded();
+    const maxIterations = 10;
+    let iteration = 0;
+    const layoutCounts = /* @__PURE__ */ new Map();
+    while (_UIView._viewsToLayout.length > 0 && iteration < maxIterations) {
+      const viewsToProcess = _UIView._viewsToLayout;
+      _UIView._viewsToLayout = [];
+      const viewDepthMap = /* @__PURE__ */ new Map();
+      for (let i = 0; i < viewsToProcess.length; i++) {
+        const view = viewsToProcess[i];
+        const layoutCount = layoutCounts.get(view) || 0;
+        if (layoutCount >= 5) {
+          console.warn("View layout cycle detected:", view);
+          continue;
+        }
+        if (!viewDepthMap.has(view)) {
+          viewDepthMap.set(view, view.withAllSuperviews.length);
+        }
+      }
+      const sortedViews = Array.from(viewDepthMap.keys()).sort((a, b) => {
+        return viewDepthMap.get(a) - viewDepthMap.get(b);
+      });
+      for (let i = 0; i < sortedViews.length; i++) {
+        const view = sortedViews[i];
+        view.layoutIfNeeded();
+        layoutCounts.set(view, (layoutCounts.get(view) || 0) + 1);
+      }
+      iteration++;
     }
-    _UIView._viewsToLayout = [];
   }
   setNeedsLayout() {
-    if (this._shouldLayout) {
+    if (this._shouldLayout && _UIView._viewsToLayout.contains(this)) {
       return;
     }
     this._shouldLayout = import_UIObject.YES;
     _UIView._viewsToLayout.push(this);
-    this._intrinsicSizesCache = {};
+    this.clearIntrinsicSizeCache();
     if (_UIView._viewsToLayout.length == 1) {
       _UIView.scheduleLayoutViewsIfNeeded();
     }
@@ -915,7 +1012,9 @@ const _UIView = class extends import_UIObject.UIObject {
     if (!this._shouldLayout) {
       return;
     }
-    this._shouldLayout = import_UIObject.NO;
+    if (!this.isVirtualLayouting) {
+      this._shouldLayout = import_UIObject.NO;
+    }
     try {
       this.layoutSubviews();
     } catch (exception) {
@@ -925,7 +1024,9 @@ const _UIView = class extends import_UIObject.UIObject {
   layoutSubviews() {
     var _a, _b;
     this.willLayoutSubviews();
-    this._shouldLayout = import_UIObject.NO;
+    if (!this.isVirtualLayouting) {
+      this._shouldLayout = import_UIObject.NO;
+    }
     if (this.constraints.length) {
       this._updateLayoutFunction = _UIView.performAutoLayout(this.viewHTMLElement, null, this.constraints);
     }
@@ -2140,9 +2241,55 @@ const _UIView = class extends import_UIObject.UIObject {
   rectangleFromView(rectangle, view) {
     return view.rectangleInView(rectangle, this);
   }
+  get contentBounds() {
+    const bounds = this.bounds;
+    const insets = this._contentInsets;
+    return new import_UIRectangle.UIRectangle(
+      insets.left,
+      insets.top,
+      bounds.height - insets.top - insets.bottom,
+      bounds.width - insets.left - insets.right
+    );
+  }
+  contentBoundsWithInset(inset) {
+    this._contentInsets = { top: inset, left: inset, bottom: inset, right: inset };
+    const bounds = this.bounds;
+    return new import_UIRectangle.UIRectangle(
+      inset,
+      inset,
+      bounds.height - inset * 2,
+      bounds.width - inset * 2
+    );
+  }
+  contentBoundsWithInsets(left, right, bottom, top) {
+    this._contentInsets = { left, right, bottom, top };
+    const bounds = this.bounds;
+    return new import_UIRectangle.UIRectangle(
+      left,
+      top,
+      bounds.height - top - bottom,
+      bounds.width - left - right
+    );
+  }
+  _getIntrinsicSizeCacheKey(constrainingHeight, constrainingWidth) {
+    return `h_${constrainingHeight}__w_${constrainingWidth}`;
+  }
+  _getCachedIntrinsicSize(cacheKey) {
+    return this._intrinsicSizesCache[cacheKey];
+  }
+  _setCachedIntrinsicSize(cacheKey, size) {
+    this._intrinsicSizesCache[cacheKey] = size.copy();
+  }
+  clearIntrinsicSizeCache() {
+    var _a;
+    this._intrinsicSizesCache = {};
+    if ((_a = this.superview) == null ? void 0 : _a.usesVirtualLayoutingForIntrinsicSizing) {
+      this.superview.clearIntrinsicSizeCache();
+    }
+  }
   intrinsicContentSizeWithConstraints(constrainingHeight = 0, constrainingWidth = 0) {
-    const cacheKey = "h_" + constrainingHeight + "__w_" + constrainingWidth;
-    const cachedResult = this._intrinsicSizesCache[cacheKey];
+    const cacheKey = this._getIntrinsicSizeCacheKey(constrainingHeight, constrainingWidth);
+    const cachedResult = this._getCachedIntrinsicSize(cacheKey);
     if (cachedResult) {
       return cachedResult;
     }
@@ -2192,85 +2339,89 @@ const _UIView = class extends import_UIObject.UIObject {
     }
     result.height = resultHeight;
     result.width = resultWidth;
-    this._intrinsicSizesCache[cacheKey] = result.copy();
+    this._setCachedIntrinsicSize(cacheKey, result);
     return result;
   }
+  _intrinsicFrameFromSubviewFrames() {
+    var _a, _b, _c, _d;
+    const framePoints = [];
+    this.subviews.forEach((subview) => {
+      subview.layoutIfNeeded();
+      framePoints.push(subview.frame.min);
+      framePoints.push(subview.frame.max);
+    });
+    const resultFrame = import_UIRectangle.UIRectangle.boundingBoxForPoints(framePoints).rectangleWithInsets(
+      -((_a = this._contentInsets) == null ? void 0 : _a.left),
+      -((_b = this._contentInsets) == null ? void 0 : _b.right),
+      -((_c = this._contentInsets) == null ? void 0 : _c.bottom),
+      -((_d = this._contentInsets) == null ? void 0 : _d.top)
+    );
+    return resultFrame;
+  }
   intrinsicContentWidth(constrainingHeight = 0) {
+    const cacheKey = this._getIntrinsicSizeCacheKey(constrainingHeight, 0);
+    const cached = this._getCachedIntrinsicSize(cacheKey);
+    if (cached) {
+      return cached.width;
+    }
     if (this.usesVirtualLayoutingForIntrinsicSizing) {
-      _UIView.isVirtualLayouting = import_UIObject.YES;
-      this.frame = this.frame.rectangleWithHeight(constrainingHeight);
-      this.layoutIfNeeded();
-      const framePoints = [];
-      this.forEachViewInSubtree((view) => {
-        if (view == this) {
-          return;
-        }
-        let frame = view.frame;
-        if (view.superview != this) {
-          frame = view.rectangleInView(
-            frame,
-            this,
-            import_UIObject.YES
-          );
-        }
-        framePoints.push(frame.min);
-        framePoints.push(frame.max);
-      });
-      const resultFrame = import_UIRectangle.UIRectangle.boundingBoxForPoints(framePoints);
-      _UIView.isVirtualLayouting = import_UIObject.NO;
+      this.startVirtualLayout();
+      let resultFrame;
+      try {
+        this.frame = this.frame.rectangleWithHeight(constrainingHeight);
+        this.layoutIfNeeded();
+        resultFrame = this._intrinsicFrameFromSubviewFrames();
+      } finally {
+        this.finishVirtualLayout();
+      }
+      this._setCachedIntrinsicSize(cacheKey, new import_UIRectangle.UIRectangle(0, 0, resultFrame.height, resultFrame.width));
       return resultFrame.width;
     }
-    return this.intrinsicContentSizeWithConstraints(constrainingHeight).width;
+    const size = this.intrinsicContentSizeWithConstraints(constrainingHeight, 0);
+    return size.width;
   }
   intrinsicContentHeight(constrainingWidth = 0) {
+    const cacheKey = this._getIntrinsicSizeCacheKey(0, constrainingWidth);
+    const cached = this._getCachedIntrinsicSize(cacheKey);
+    if (cached) {
+      return cached.height;
+    }
     if (this.usesVirtualLayoutingForIntrinsicSizing) {
-      _UIView.isVirtualLayouting = import_UIObject.YES;
-      this.frame = this.frame.rectangleWithWidth(constrainingWidth);
-      this.layoutIfNeeded();
-      const framePoints = [];
-      this.forEachViewInSubtree((view) => {
-        if (view == this) {
-          return;
-        }
-        let frame = view.frame;
-        if (view.superview != this) {
-          frame = view.rectangleInView(
-            frame,
-            this,
-            import_UIObject.YES
-          );
-        }
-        framePoints.push(frame.min);
-        framePoints.push(frame.max);
-      });
-      const resultFrame = import_UIRectangle.UIRectangle.boundingBoxForPoints(framePoints);
-      _UIView.isVirtualLayouting = import_UIObject.NO;
+      this.startVirtualLayout();
+      let resultFrame;
+      try {
+        this.frame = this.frame.rectangleWithWidth(constrainingWidth);
+        this.layoutIfNeeded();
+        resultFrame = this._intrinsicFrameFromSubviewFrames();
+      } finally {
+        this.finishVirtualLayout();
+      }
+      this._setCachedIntrinsicSize(cacheKey, new import_UIRectangle.UIRectangle(0, 0, resultFrame.height, resultFrame.width));
       return resultFrame.height;
     }
-    return this.intrinsicContentSizeWithConstraints(void 0, constrainingWidth).height;
+    const size = this.intrinsicContentSizeWithConstraints(0, constrainingWidth);
+    if (isNaN(size.height)) {
+      console.error("NaN in intrinsicContentHeight", this);
+      var asd = 1;
+    }
+    return size.height;
   }
   intrinsicContentSize() {
+    const cacheKey = this._getIntrinsicSizeCacheKey(0, 0);
+    const cached = this._getCachedIntrinsicSize(cacheKey);
+    if (cached) {
+      return cached;
+    }
     if (this.usesVirtualLayoutingForIntrinsicSizing) {
-      _UIView.isVirtualLayouting = import_UIObject.YES;
-      this.layoutIfNeeded();
-      const framePoints = [];
-      this.forEachViewInSubtree((view) => {
-        if (view == this) {
-          return;
-        }
-        let frame = view.frame;
-        if (view.superview != this) {
-          frame = view.rectangleInView(
-            frame,
-            this,
-            import_UIObject.YES
-          );
-        }
-        framePoints.push(frame.min);
-        framePoints.push(frame.max);
-      });
-      const resultFrame = import_UIRectangle.UIRectangle.boundingBoxForPoints(framePoints);
-      _UIView.isVirtualLayouting = import_UIObject.NO;
+      this.startVirtualLayout();
+      let resultFrame;
+      try {
+        this.layoutIfNeeded();
+        resultFrame = this._intrinsicFrameFromSubviewFrames();
+      } finally {
+        this.finishVirtualLayout();
+      }
+      this._setCachedIntrinsicSize(cacheKey, resultFrame);
       return resultFrame;
     }
     return import_UIObject.nil;
@@ -2291,7 +2442,9 @@ UIView.resizeObserver = new ResizeObserver((entries, observer) => {
 UIView._onWindowTouchMove = import_UIObject.nil;
 UIView._onWindowMouseMove = import_UIObject.nil;
 UIView._onWindowMouseup = import_UIObject.nil;
-UIView.isVirtualLayouting = import_UIObject.NO;
+UIView._virtualLayoutingDepth = 0;
+UIView._pageDimensionsCacheValid = false;
+UIView._resizeObserverInitialized = false;
 UIView._transformAttribute = ("transform" in document.documentElement.style ? "transform" : void 0) || ("-webkit-transform" in document.documentElement.style ? "-webkit-transform" : "undefined") || ("-moz-transform" in document.documentElement.style ? "-moz-transform" : "undefined") || ("-ms-transform" in document.documentElement.style ? "-ms-transform" : "undefined") || ("-o-transform" in document.documentElement.style ? "-o-transform" : "undefined");
 UIView.constraintAttribute = {
   "left": AutoLayout.Attribute.LEFT,