lightning-base-components 1.27.5-alpha → 1.28.4-alpha

package/src/lightning/positionLibrary/direction.d.ts

@@ -0,0 +1,27 @@
+export function normalizeDirection(direction: any, defaultValue: any): string;
+export function mapToHorizontal(value: any): any;
+export function mapToVertical(value: any): any;
+export function flipDirection(value: any): any;
+export function isValidDirection(value: any): any;
+export function checkFlipPossibility(parent: any, element: any, target: any, leftAsBoundary: any): {
+    shouldAlignToLeft: boolean;
+    shouldAlignToRight: boolean;
+    hasSpaceAbove: boolean;
+    hasSpaceBelow: boolean;
+    centerOverflow: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+};
+export namespace Direction {
+    let Center: string;
+    let Middle: string;
+    let Right: string;
+    let Left: string;
+    let Bottom: string;
+    let Top: string;
+    let Default: string;
+}
+//# sourceMappingURL=direction.d.ts.map

package/src/lightning/positionLibrary/direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direction.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/direction.js"],"names":[],"mappings":"AAyDA,8EAaC;AAED,iDAGC;AAED,+CAGC;AAED,+CAGC;AAGD,kDAEC;AAGD;;;;;;;;;;;EAmKC"}

package/src/lightning/positionLibrary/direction.js

@@ -6,10 +6,7 @@
 import { normalizeString } from 'lightning/utilsPrivate';
 import { WindowManager } from './util';
 import { features } from 'lightning/features';
-
-// TODO: Remove, not currently in use.
 const ALIGN_REGEX = /^(left|right|center)\s(top|bottom|center)$/;
-
 export const Direction = {
     Center: 'center',
     Middle: 'middle',
@@ -19,19 +16,16 @@ export const Direction = {
     Top: 'top',
     Default: 'default',
 };
-
 const VerticalMap = {
     top: Direction.Top,
     bottom: Direction.Bottom,
     center: Direction.Middle,
 };
-
 const HorizontalMap = {
     left: Direction.Left,
     right: Direction.Right,
     center: Direction.Center,
 };
-
 const FlipMap = {
     left: Direction.Right,
     right: Direction.Left,
@@ -40,26 +34,20 @@ const FlipMap = {
     center: Direction.Center,
     default: Direction.Right,
 };
-
 function getContainerSize(parent) {
     if (parent) {
         return parent.getBoundingClientRect();
     }
-
     const rect = {
-        width:
-            WindowManager.window.innerWidth || document.body.clientWidth || 0,
-        height:
-            WindowManager.window.innerHeight || document.body.clientHeight || 0,
+        width: WindowManager.window.innerWidth || document.body.clientWidth || 0,
+        height: WindowManager.window.innerHeight || document.body.clientHeight || 0,
         top: 0,
         left: 0,
     };
-
     rect.bottom = rect.height;
     rect.right = rect.width;
     return rect;
 }
-
 export function normalizeDirection(direction, defaultValue) {
     return normalizeString(direction, {
         fallbackValue: defaultValue || Direction.Default,
@@ -74,184 +62,121 @@ export function normalizeDirection(direction, defaultValue) {
         ],
     });
 }
-
 export function mapToHorizontal(value) {
     value = normalizeDirection(value, Direction.Left);
     return HorizontalMap[value];
 }
-
 export function mapToVertical(value) {
     value = normalizeDirection(value, Direction.Left);
     return VerticalMap[value];
 }
-
 export function flipDirection(value) {
     value = normalizeDirection(value, Direction.Left);
     return FlipMap[value];
 }
-
-// TODO: Remove, not currently in use.
 export function isValidDirection(value) {
     return value && value.match(ALIGN_REGEX);
 }
-
-// eslint-disable-next-line complexity
 export function checkFlipPossibility(parent, element, target, leftAsBoundary) {
     const viewPort = getContainerSize(parent);
     const windowViewPort = getContainerSize();
     const elemRect = element.getBoundingClientRect();
     const referenceElemRect = target.getBoundingClientRect();
-    const height =
-        typeof elemRect.height !== 'undefined'
-            ? elemRect.height
-            : elemRect.bottom - elemRect.top;
-    const width =
-        typeof elemRect.width !== 'undefined'
-            ? elemRect.width
-            : elemRect.right - elemRect.left;
-
-    // TODO: We'll need to revisit the leftAsBoundary config property. Either we'll need a better
-    // name to cover the RTL language cases and maybe open up the possibility of bounding the
-    // element to the target in both the horizontal and vertical directions.
-
-    // The boundary shrinks the available area to the edge of the target rather than the viewport.
+    const height = typeof elemRect.height !== 'undefined'
+        ? elemRect.height
+        : elemRect.bottom - elemRect.top;
+    const width = typeof elemRect.width !== 'undefined'
+        ? elemRect.width
+        : elemRect.right - elemRect.left;
     let rightAsBoundary = false;
     let isRTL = false;
-    // eslint-disable-next-line @lwc/lwc/ssr-no-restricted-browser-globals
     if (document.dir === 'rtl') {
         rightAsBoundary = leftAsBoundary;
         leftAsBoundary = false;
         isRTL = true;
     }
-
-    // Bug Fix for https://gus.lightning.force.com/lightning/r/ADM_Work__c/a07B0000008DxOhIAK/view
-    // If viewport is scrollableParent, then should count the top of scrollerParent,
-    // otherwise, window top is 0. no change to original logic.
-    // When used in console app, console's viewport is not window, but a scrollable div, then popup can be cut off easily.
-    // scrollable parent => if any parent element set overflow-y:auto, then inner element won't popup, unless use position:fix.
     const aboveSpace = referenceElemRect.top - viewPort.top - height;
     const belowSpace = viewPort.height - referenceElemRect.bottom - height;
-
-    // If there is scrollable parent, always check aboveSpace > 0
-    let hasSpaceAbove =
-        aboveSpace >= 0 ||
+    let hasSpaceAbove = aboveSpace >= 0 ||
         (parent == null && belowSpace < 0 && aboveSpace > belowSpace);
-    let hasSpaceBelow =
-        belowSpace >= 0 || (aboveSpace < 0 && belowSpace > aboveSpace);
-
-    // Assuming left alignment is specified this tests if:
-    // - there's room to accommodate the element with right alignment
-    //      - within the viewport, if parent present
-    // - there's not enough room to accommodate the element with left alignment
+    let hasSpaceBelow = belowSpace >= 0 || (aboveSpace < 0 && belowSpace > aboveSpace);
     let shouldAlignToRight = false;
     if (parent) {
         if (!features.enablePositionLibFlipCalcWithViewportRight) {
             shouldAlignToRight =
                 referenceElemRect.right - viewPort.left >= width &&
-                referenceElemRect.left + width >
-                    (rightAsBoundary ? referenceElemRect.right : viewPort.width);
-        } else {
+                    referenceElemRect.left + width >
+                        (rightAsBoundary ? referenceElemRect.right : viewPort.width);
+        }
+        else {
             shouldAlignToRight =
-            referenceElemRect.right - viewPort.left >= width &&
-            referenceElemRect.left + width >
-                (rightAsBoundary ? referenceElemRect.right : viewPort.right);
+                referenceElemRect.right - viewPort.left >= width &&
+                    referenceElemRect.left + width >
+                        (rightAsBoundary ? referenceElemRect.right : viewPort.right);
         }
-    } else {
+    }
+    else {
         shouldAlignToRight =
             referenceElemRect.right >= width &&
-            referenceElemRect.left + width >
-                (rightAsBoundary ? referenceElemRect.right : viewPort.width);
+                referenceElemRect.left + width >
+                    (rightAsBoundary ? referenceElemRect.right : viewPort.width);
     }
-
-    // Assuming right alignment is specified this tests if:
-    // - there's room to accommodate the element with left alignment
-    //      - within the viewport if parent present
-    // - there's not enough room to accommodate the element with right alignment
     let shouldAlignToLeft = false;
     if (parent) {
         shouldAlignToLeft =
             referenceElemRect.left + width <= viewPort.right &&
-            referenceElemRect.right - viewPort.left - width <
-                (leftAsBoundary ? referenceElemRect.left : 0);
-    } else {
+                referenceElemRect.right - viewPort.left - width <
+                    (leftAsBoundary ? referenceElemRect.left : 0);
+    }
+    else {
         shouldAlignToLeft =
             referenceElemRect.left + width <= viewPort.width &&
-            referenceElemRect.right - width <
-                (leftAsBoundary ? referenceElemRect.left : 0);
+                referenceElemRect.right - width <
+                    (leftAsBoundary ? referenceElemRect.left : 0);
     }
-
     const spaceRemainingRight = viewPort.width - referenceElemRect.left;
     const spaceRemainingLeft = referenceElemRect.right;
-
     if (!shouldAlignToLeft && !shouldAlignToRight && parent) {
         shouldAlignToRight =
             (referenceElemRect.right - viewPort.left >= width ||
                 referenceElemRect.right >= width) &&
-            referenceElemRect.left + width >
-                (rightAsBoundary ? referenceElemRect.right : viewPort.width);
-
+                referenceElemRect.left + width >
+                    (rightAsBoundary ? referenceElemRect.right : viewPort.width);
         shouldAlignToLeft =
             (referenceElemRect.left + width <= viewPort.right ||
                 referenceElemRect.left + width <= windowViewPort.width) &&
-            referenceElemRect.right - width <
-                (leftAsBoundary ? referenceElemRect.left : 0);
-    } else if (
-        // W-13716578 W-14991047
-        // Align to side with maximum available space only if:
-        //  - it cannot align to left based on previous checks
-        //  - it cannot align to right based on previous checks
-        //  - the available space on either side does not fully fit element width
-        // Check #3 is for when there is space on both sides, then both shouldAlignToLeft and shouldAlignToRight
-        // are false, but we want it to use the default alignment instead of max available space
-
-        !shouldAlignToLeft &&
+                referenceElemRect.right - width <
+                    (leftAsBoundary ? referenceElemRect.left : 0);
+    }
+    else if (!shouldAlignToLeft &&
         !shouldAlignToRight &&
         spaceRemainingRight < width &&
-        spaceRemainingLeft < width
-    ) {
+        spaceRemainingLeft < width) {
         shouldAlignToRight = spaceRemainingLeft > spaceRemainingRight;
         shouldAlignToLeft = spaceRemainingLeft < spaceRemainingRight;
     }
-
-    /* W-15328389 RTL is one area where there have been bugs since long ago, the following change is an impactful in
-    nature and spans multiple components, given the history of the impact this library creates we
-    wanted to localize the change to tooltip where this bug was reported, but going forward when we add multiple other
-    components we will remove this check provided we have similar bugs on other components */
-
-    if (
-        isRTL &&
+    if (isRTL &&
         !shouldAlignToLeft &&
         !shouldAlignToRight &&
-        element.tagName === 'LIGHTNING-PRIMITIVE-BUBBLE'
-    ) {
+        element.tagName === 'LIGHTNING-PRIMITIVE-BUBBLE') {
         shouldAlignToRight = spaceRemainingLeft > spaceRemainingRight;
         shouldAlignToLeft = spaceRemainingLeft < spaceRemainingRight;
     }
-
-    // If there is no space above and below, recalculate space based on window
-    // when there is still no space above and below based on window then select the maximum available space
-
-    if (
-        !hasSpaceAbove &&
+    if (!hasSpaceAbove &&
         !hasSpaceBelow &&
         parent &&
         element.style &&
-        element.style.position === 'fixed'
-    ) {
+        element.style.position === 'fixed') {
         hasSpaceAbove = referenceElemRect.top - windowViewPort.top - height > 0;
         hasSpaceBelow =
             windowViewPort.height - referenceElemRect.bottom - height > 0;
     }
-
-    // Assuming center alignment, does the viewport have space to fit half of the element around
-    // the target?
     const centerOverflow = {
         left: referenceElemRect.left - (width * 0.5) < 0,
         right: referenceElemRect.right + (width * 0.5) > viewPort.width,
         top: referenceElemRect.top - (height * 0.5) < 0,
         bottom: referenceElemRect.bottom + (height * 0.5) > viewPort.height,
     };
-
     return {
         shouldAlignToLeft,
         shouldAlignToRight,

package/src/lightning/positionLibrary/elementProxy.d.ts

@@ -0,0 +1,29 @@
+export class ElementProxy {
+    constructor(el: any, id: any);
+    id: any;
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    _dirty: boolean;
+    _node: any;
+    _releaseCb: any;
+    setupObserver(): void;
+    _observer: any;
+    setReleaseCallback(cb: any, scope: any): void;
+    checkNodeIsInDom(): boolean;
+    refresh(): boolean | void;
+    getNode(): any;
+    isDirty(): boolean;
+    getElementZoomRatio(): number;
+    bake(): void;
+    originalHeight: any;
+    originalWidth: any;
+    setDirection(direction: any, val: any): void;
+    _restoreSize: boolean;
+    release(): void;
+    querySelectorAll(selector: any): any;
+}
+//# sourceMappingURL=elementProxy.d.ts.map

package/src/lightning/positionLibrary/elementProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementProxy.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/elementProxy.js"],"names":[],"mappings":"AAEA;IACI,8BA2BC;IA1BG,QAAY;IACZ,cAAc;IACd,eAAe;IACf,aAAa;IACb,YAAY;IACZ,cAAc;IACd,eAAe;IACf,gBAAmB;IACnB,WAAiB;IACjB,gBAAsB;IAmB1B,sBAuBC;IAfO,eAEC;IAeT,8CAGC;IAED,4BAOC;IAED,0BA+CC;IAED,eAEC;IAED,mBAEC;IAED,8BAYC;IAED,aAgFC;IAfW,oBAA6C;IAG7C,mBAA2C;IAcvD,6CAOC;IAFO,sBAAwB;IAIhC,gBAkBC;IAED,qCAEC;CACJ"}

package/src/lightning/positionLibrary/elementProxy.js

@@ -4,7 +4,6 @@
  * For full license text, see the LICENSE.txt file
  */
 import { isInDom, WindowManager, pxToFloat } from './util';
-
 export class ElementProxy {
     constructor(el, id) {
         this.id = id;
@@ -17,37 +16,19 @@ export class ElementProxy {
         this._dirty = false;
         this._node = null;
         this._releaseCb = null;
-
         if (!el) {
             throw new Error('Element missing');
         }
-
-        // W-3262919
-        // for some reason I cannot figure out sometimes the
-        // window, which clearly a window object, is not the window object
-        // this will correct that. It might be related to locker
         if (WindowManager.isWindow(el)) {
             el = WindowManager.window;
         }
-
         this._node = el;
         this.setupObserver();
         this.refresh();
     }
-
     setupObserver() {
-        // this check is because phantomjs does not support
-        // mutation observers. The consqeuence here
-        // is that any browser without mutation observers will
-        // fail to update dimensions if they changwe after the proxy
-        // is created and the proxy is not not refreshed
         if (WindowManager.MutationObserver && !this._node.isObserved) {
-            // Use mutation observers to invalidate cache. It's magic!
-            this._observer = new WindowManager.MutationObserver(
-                this.refresh.bind(this)
-            );
-
-            // do not observe the window
+            this._observer = new WindowManager.MutationObserver(this.refresh.bind(this));
             if (!WindowManager.isWindow(this._node)) {
                 this._observer.observe(this._node, {
                     attributes: true,
@@ -59,47 +40,34 @@ export class ElementProxy {
             }
         }
     }
-
     setReleaseCallback(cb, scope) {
         const scopeObj = scope || this;
         this._releaseCb = cb.bind(scopeObj);
     }
-
     checkNodeIsInDom() {
-        // if underlying DOM node is gone,
-        // this proxy should be released
         if (!isInDom(this._node)) {
             return false;
         }
         return true;
     }
-
     refresh() {
         const w = WindowManager.window;
-
         if (!this.isDirty()) {
             if (!this.checkNodeIsInDom()) {
                 return this.release();
             }
-
             let box, x, scrollTop, scrollLeft;
-
             if (typeof w.pageYOffset !== 'undefined') {
                 scrollTop = w.pageYOffset;
                 scrollLeft = w.pageXOffset;
-            } else {
+            }
+            else {
                 scrollTop = w.scrollY;
                 scrollLeft = w.scrollX;
             }
-
             if (!WindowManager.isWindow(this._node)) {
-                // force paint
-                // eslint-disable-next-line no-unused-vars
                 const offsetHeight = this._node.offsetHeight;
                 box = this._node.getBoundingClientRect();
-
-                // not using integers causes weird rounding errors
-                // eslint-disable-next-line guard-for-in
                 for (x in box) {
                     this[x] = Math.floor(box[x]);
                 }
@@ -107,7 +75,8 @@ export class ElementProxy {
                 this.bottom = Math.floor(this.top + box.height);
                 this.left = Math.floor(this.left + scrollLeft);
                 this.right = Math.floor(this.left + box.width);
-            } else {
+            }
+            else {
                 box = {};
                 this.width = WindowManager.documentElement.clientWidth;
                 this.height = WindowManager.documentElement.clientHeight;
@@ -117,43 +86,34 @@ export class ElementProxy {
                     WindowManager.documentElement.clientWidth + scrollLeft;
                 this.bottom = WindowManager.documentElement.clientHeight;
             }
-
             this._dirty = false;
         }
         return this._dirty;
     }
-
     getNode() {
         return this._node;
     }
-
     isDirty() {
         return this._dirty;
     }
-
     getElementZoomRatio() {
         const element = this._node;
         const rect = element.getBoundingClientRect();
-
         const offsetWidth = element.offsetWidth || Math.round(rect.width) || 1;
-        const offsetHeight =
-            element.offsetHeight || Math.round(rect.height) || 1;
+        const offsetHeight = element.offsetHeight || Math.round(rect.height) || 1;
         const actualWidth = Math.round(rect.width);
         const actualHeight = Math.round(rect.height);
         const widthRatio = Number((actualWidth / offsetWidth).toFixed(2));
         const heightRatio = Number((actualHeight / offsetHeight).toFixed(2));
         return Math.min(widthRatio, heightRatio);
     }
-
     bake() {
         const w = WindowManager.window;
         const absPos = this._node.getBoundingClientRect();
         const style = w.getComputedStyle(this._node) || this._node.style;
-
         const hasPageOffset = typeof w.pageYOffset !== 'undefined';
         const scrollTop = hasPageOffset ? w.pageYOffset : w.scrollY;
         const scrollLeft = hasPageOffset ? w.pageXOffset : w.scrollX;
-
         const originalLeft = style.left.match(/auto|fixed/)
             ? '0'
             : pxToFloat(style.left);
@@ -162,80 +122,53 @@ export class ElementProxy {
             : pxToFloat(style.top);
         const zoomLevel = this.getElementZoomRatio();
         const adjustForZoom = (value) => value / zoomLevel;
-
         const marginTop = adjustForZoom(pxToFloat(style.marginTop));
-
-        // since this.top dosent consist of marginTop , we need to subtract the margin to the top from absTop
-        const adjustedAbsPosTop =
-            adjustForZoom(Math.round(absPos.top)) +
+        const adjustedAbsPosTop = adjustForZoom(Math.round(absPos.top)) +
             scrollTop -
             (adjustForZoom(this.top) <
-            adjustForZoom(Math.round(absPos.top)) + scrollTop
+                adjustForZoom(Math.round(absPos.top)) + scrollTop
                 ? marginTop
                 : -marginTop);
-        const marginAdjustment =
-            adjustForZoom(this.top) < adjustForZoom(adjustedAbsPosTop)
-                ? marginTop
-                : -marginTop;
-        const zoomAdjustedAbsLeft = adjustForZoom(
-            Math.round(absPos.left) + scrollLeft
-        );
-        const zoomAdjustedAbsTop = adjustForZoom(
-            Math.round(absPos.top) + scrollTop
-        );
-
-        let leftDif = Math.round(
-            adjustForZoom(this.left) - zoomAdjustedAbsLeft
-        );
-        const topDif = Math.round(
-            adjustForZoom(this.top) - (zoomAdjustedAbsTop + marginAdjustment)
-        );
-
+        const marginAdjustment = adjustForZoom(this.top) < adjustForZoom(adjustedAbsPosTop)
+            ? marginTop
+            : -marginTop;
+        const zoomAdjustedAbsLeft = adjustForZoom(Math.round(absPos.left) + scrollLeft);
+        const zoomAdjustedAbsTop = adjustForZoom(Math.round(absPos.top) + scrollTop);
+        let leftDif = Math.round(adjustForZoom(this.left) - zoomAdjustedAbsLeft);
+        const topDif = Math.round(adjustForZoom(this.top) - (zoomAdjustedAbsTop + marginAdjustment));
         const viewPortWidth = w.innerWidth || document.body.clientWidth;
         let rightPos = parseInt(style.right, 10);
         const elementWidth = this._node.offsetWidth;
         const zoomAdjustedWidth = elementWidth * zoomLevel;
-        if (
-            originalLeft + leftDif + zoomAdjustedWidth > viewPortWidth &&
-            rightPos <= 0
-        ) {
+        if (originalLeft + leftDif + zoomAdjustedWidth > viewPortWidth &&
+            rightPos <= 0) {
             rightPos = rightPos < 0 ? -rightPos : leftDif;
             this._node.style.right = `${-rightPos}px`;
             leftDif = 0;
         }
-
         this._node.style.left = `${originalLeft + leftDif}px`;
         this._node.style.top = `${originalTop + topDif}px`;
-
         if (this._restoreSize) {
-            // Only store the first height/width which is the original height/width.
             if (this.originalHeight === undefined) {
                 this.originalHeight = this._node.style.height;
             }
             if (this.originalWidth === undefined) {
                 this.originalWidth = this._node.style.width;
             }
-
-            // Apply dimensions accounting for zoom
             const adjustedWidth = adjustForZoom(this.width);
             const adjustedHeight = adjustForZoom(this.height);
-
             this._node.style.width = `${adjustedWidth}px`;
             this._node.style.height = `${adjustedHeight}px`;
         }
-
         this._dirty = false;
     }
-
     setDirection(direction, val) {
         this[direction] = val;
         this._dirty = true;
-        // if size is changed, should restore the original size.
         if (direction === 'height' || direction === 'width') {
             this._restoreSize = true;
         }
     }
-
     release() {
         if (this._restoreSize) {
             this._node.style.width = this.originalWidth;
@@ -247,15 +180,11 @@ export class ElementProxy {
         if (this._releaseCb) {
             this._releaseCb(this);
         }
-
-        // Due to https://github.com/salesforce/lwc/pull/1423
-        // require to call disconnect explicitly.
         if (this._observer) {
             this._observer.disconnect();
             this._observer = null;
         }
     }
-
     querySelectorAll(selector) {
         return this._node.querySelectorAll(selector);
     }

package/src/lightning/positionLibrary/elementProxyCache.d.ts

@@ -0,0 +1,8 @@
+export function releaseOrphanProxies(): void;
+export function bakeOff(): void;
+export function getReferenceCount(proxy: any): any;
+export function release(proxy: any): void;
+export function reset(): void;
+export function createProxy(element: any): any;
+export function count(): number;
+//# sourceMappingURL=elementProxyCache.d.ts.map

package/src/lightning/positionLibrary/elementProxyCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementProxyCache.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/elementProxyCache.js"],"names":[],"mappings":"AAoFA,6CAEC;AAED,gCAEC;AAED,mDAEC;AAED,0CAEC;AAED,8BAEC;AAED,+CAEC;AAED,gCAEC"}