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

package/src/lightning/positionLibrary/reposition.js

@@ -5,34 +5,27 @@
  */
 import { bakeOff } from './elementProxyCache';
 import { getZIndexBaseline } from 'lightning/utilsPrivate';
-
 class RepositionQueue {
     callbacks = [];
     repositionScheduled = false;
     _constraints = [];
     timeoutId = 0;
     lastIndex = getZIndexBaseline();
-
     eventsBound = false;
-
     get nextIndex() {
         return this.lastIndex++;
     }
-
     get constraints() {
         return this._constraints;
     }
-
     set constraints(value) {
         this._constraints = this._constraints.concat(value);
     }
-
     dispatchRepositionCallbacks() {
         while (this.callbacks.length > 0) {
             this.callbacks.shift()();
         }
     }
-
     add(callback) {
         if (typeof callback === 'function') {
             this.callbacks.push(callback);
@@ -40,34 +33,22 @@ class RepositionQueue {
         }
         return false;
     }
-
     scheduleReposition(callback) {
         if (this.timeoutId === 0) {
-            // eslint-disable-next-line @lwc/lwc/no-async-operation
             this.timeoutId = setTimeout(() => {
                 this.reposition(callback);
             }, 10);
         }
     }
-
     reposition(callback) {
-        // all the callbacks will be called
         if (typeof callback === 'function') {
             this.callbacks.push(callback);
         }
-        // this is for throttling
         clearTimeout(this.timeoutId);
         this.timeoutId = 0;
-
-        // this semaphore is to make sure
-        // if reposition is called twice within one frame
-        // we only run this once
         if (!this.repositionScheduled) {
-            // eslint-disable-next-line @lwc/lwc/no-async-operation, @lwc/lwc/ssr-no-restricted-browser-globals
             requestAnimationFrame(() => {
                 this.repositionScheduled = false;
-                // this must be executed in order or constraints
-                // will behave oddly
                 this._constraints = this._constraints.filter((constraint) => {
                     if (!constraint.destroyed) {
                         constraint.computeDisplacement().computePosition();
@@ -75,68 +56,52 @@ class RepositionQueue {
                     }
                     return false;
                 });
-
                 bakeOff();
                 this.dispatchRepositionCallbacks();
             });
             this.repositionScheduled = true;
         }
     }
-
     get repositioning() {
         if (!this._reposition) {
             this._reposition = this.scheduleReposition.bind(this);
         }
         return this._reposition;
     }
-
     bindEvents() {
         if (!this.eventsBound) {
-            // eslint-disable-next-line @lwc/lwc/ssr-no-restricted-browser-globals
             window.addEventListener('resize', this.repositioning);
-            // eslint-disable-next-line @lwc/lwc/ssr-no-restricted-browser-globals
             window.addEventListener('scroll', this.repositioning);
             this.eventsBound = true;
         }
     }
-
     detachEvents() {
-        // eslint-disable-next-line @lwc/lwc/ssr-no-restricted-browser-globals
         window.removeEventListener('resize', this.repositioning);
-        // eslint-disable-next-line @lwc/lwc/ssr-no-restricted-browser-globals
         window.removeEventListener('scroll', this.repositioning);
         this.eventsBound = false;
     }
-
     rebase(index) {
         if (this.lastIndex <= index) {
             this.lastIndex = index + 1;
         }
     }
 }
-
 const positionQueue = new RepositionQueue();
-
 export function scheduleReposition(callback) {
     positionQueue.scheduleReposition(callback);
 }
-
 export function bindEvents() {
     positionQueue.bindEvents();
 }
-
 export function addConstraints(list) {
     positionQueue.constraints = list;
 }
-
 export function reposition(callback) {
     positionQueue.reposition(callback);
 }
-
 export function nextIndex() {
     return positionQueue.nextIndex;
 }
-
 export function rebaseIndex(index) {
     return positionQueue.rebase(index);
 }

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

@@ -0,0 +1,13 @@
+export class TransformBuilder {
+    type(value: any): this;
+    _type: any;
+    align(horizontal: any, vertical: any): this;
+    _transformX: any;
+    _transformY: any;
+    pad(value: any): this;
+    _pad: number;
+    boxDirections(value: any): this;
+    _boxDirections: any;
+    build(): any;
+}
+//# sourceMappingURL=transformBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformBuilder.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/transformBuilder.js"],"names":[],"mappings":"AAGA;IACI,uBAGC;IAFG,WAAkB;IAItB,4CAIC;IAHG,iBAAmD;IACnD,iBAAiD;IAIrD,sBAGC;IAFG,aAA+B;IAInC,gCAGC;IAFG,oBAA2B;IAG/B,aAUC;CACJ"}

package/src/lightning/positionLibrary/transformBuilder.js

@@ -5,24 +5,20 @@
  */
 import { Transformers, toTransformFunctions } from './transformers';
 import { Direction } from './direction';
-
 export class TransformBuilder {
     type(value) {
         this._type = value;
         return this;
     }
-
     align(horizontal, vertical) {
         this._transformX = toTransformFunctions(horizontal);
         this._transformY = toTransformFunctions(vertical);
         return this;
     }
-
     pad(value) {
         this._pad = parseInt(value, 10);
         return this;
     }
-
     boxDirections(value) {
         this._boxDirections = value;
         return this;
@@ -31,11 +27,6 @@ export class TransformBuilder {
         const AConstructor = Transformers[this._type]
             ? Transformers[this._type]
             : Transformers[Direction.Default];
-        return new AConstructor(
-            this._pad || 0,
-            this._boxDirections || {},
-            this._transformX || toTransformFunctions(Direction.left),
-            this._transformY || toTransformFunctions(Direction.left)
-        );
+        return new AConstructor(this._pad || 0, this._boxDirections || {}, this._transformX || toTransformFunctions(Direction.left), this._transformY || toTransformFunctions(Direction.left));
     }
 }

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

@@ -0,0 +1,83 @@
+export function toTransformFunctions(value: any): any;
+export class LeftTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        left: number;
+    };
+}
+export const Transformers: {
+    top: typeof TopTransformer;
+    bottom: typeof BottomTransFormer;
+    center: typeof CenterTransformer;
+    middle: typeof MiddleTransformer;
+    left: typeof LeftTransformer;
+    right: typeof RightTransformer;
+    below: typeof BelowTransformer;
+    'bounding box': typeof BoundingBoxTransformer;
+    'shrinking box': typeof ShrinkingBoxTransformer;
+    'inverse bounding box': typeof InverseBoundingBoxTransformer;
+    default: typeof Transformer;
+};
+declare class Transformer {
+    constructor(pad: any, boxDirections: any, transformX: any, transformY: any);
+    pad: any;
+    boxDirections: any;
+    transformX: any;
+    transformY: any;
+    transform(): void;
+}
+declare class TopTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: number;
+    };
+}
+declare class BottomTransFormer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: number;
+    };
+}
+declare class CenterTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        left: number;
+    };
+}
+declare class MiddleTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: number;
+    };
+}
+declare class RightTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        left: number;
+    };
+}
+declare class BelowTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: any;
+    } | {
+        top?: undefined;
+    };
+}
+declare class BoundingBoxTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: any;
+        left: any;
+    };
+}
+declare class ShrinkingBoxTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        top: any;
+        height: number;
+        left: any;
+        width: number;
+        right: number;
+        bottom: number;
+    };
+}
+declare class InverseBoundingBoxTransformer extends Transformer {
+    transform(targetBox: any, elementBox: any): {
+        left: any;
+        top: any;
+    };
+}
+export {};
+//# sourceMappingURL=transformers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/transformers.js"],"names":[],"mappings":"AAwPA,sDAEC;AAnMD;IACI;;MAOC;CACJ;AA0KD;;;;;;;;;;;;EAYE;AAtPF;IACI,4EAKC;IAJG,SAAmB;IACnB,mBAAiE;IACjE,gBAA8C;IAC9C,gBAA8C;IAElD,kBAEC;CACJ;AAED;IACI;;MAMC;CACJ;AAED;IACI;;MAQC;CACJ;AAED;IACI;;MAOC;CACJ;AAED;IACI;;MAMC;CACJ;AAaD;IACI;;MAQC;CACJ;AAED;IACI;;;;MAGC;CACJ;AAwDD;IACI;;;MAoCC;CACJ;AA3FD;IACI;;;;;;;MAkDC;CACJ;AAyCD;IACI;;;MAoCC;CACJ"}

package/src/lightning/positionLibrary/transformers.js

@@ -7,221 +7,148 @@ class Transformer {
     constructor(pad, boxDirections, transformX, transformY) {
         this.pad = pad || 0;
         this.boxDirections = boxDirections || { left: true, right: true };
-        this.transformX = transformX || function () {};
-        this.transformY = transformY || function () {};
+        this.transformX = transformX || function () { };
+        this.transformY = transformY || function () { };
     }
     transform() {
-        // no-op
     }
 }
-
 class TopTransformer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            top: Math.floor(
-                this.transformY(targetBox.top, targetBox, elementBox) + this.pad
-            ),
+            top: Math.floor(this.transformY(targetBox.top, targetBox, elementBox) + this.pad),
         };
     }
 }
-
 class BottomTransFormer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            top: Math.floor(
-                this.transformY(targetBox.top, targetBox, elementBox) -
-                    elementBox.height -
-                    this.pad
-            ),
+            top: Math.floor(this.transformY(targetBox.top, targetBox, elementBox) -
+                elementBox.height -
+                this.pad),
         };
     }
 }
-
 class CenterTransformer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            left: Math.floor(
-                this.transformX(targetBox.left, targetBox, elementBox) -
-                    (0.5 * elementBox.width)
-            ),
+            left: Math.floor(this.transformX(targetBox.left, targetBox, elementBox) -
+                (0.5 * elementBox.width)),
         };
     }
 }
-
 class MiddleTransformer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            top: Math.floor(
-                0.5 * (((2 * targetBox.top) + targetBox.height) - elementBox.height)
-            ),
+            top: Math.floor(0.5 * (((2 * targetBox.top) + targetBox.height) - elementBox.height)),
         };
     }
 }
-
 export class LeftTransformer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            left: Math.floor(
-                this.transformX(targetBox.left, targetBox, elementBox) +
-                    this.pad
-            ),
+            left: Math.floor(this.transformX(targetBox.left, targetBox, elementBox) +
+                this.pad),
         };
     }
 }
-
 class RightTransformer extends Transformer {
     transform(targetBox, elementBox) {
         return {
-            left: Math.floor(
-                this.transformX(targetBox.left, targetBox, elementBox) -
-                    elementBox.width -
-                    this.pad
-            ),
+            left: Math.floor(this.transformX(targetBox.left, targetBox, elementBox) -
+                elementBox.width -
+                this.pad),
         };
     }
 }
-
 class BelowTransformer extends Transformer {
     transform(targetBox, elementBox) {
         const top = targetBox.top + targetBox.height + this.pad;
         return elementBox.top < top ? { top } : {};
     }
 }
-const MIN_HEIGHT = 36; // Minimum Line Height
+const MIN_HEIGHT = 36;
 const MIN_WIDTH = 36;
 class ShrinkingBoxTransformer extends Transformer {
     transform(targetBox, elementBox) {
         const retBox = {};
-
-        if (
-            this.boxDirections.top &&
-            elementBox.top < targetBox.top + this.pad
-        ) {
+        if (this.boxDirections.top &&
+            elementBox.top < targetBox.top + this.pad) {
             retBox.top = targetBox.top + this.pad;
-            retBox.height = Math.max(
-                elementBox.height - (retBox.top - elementBox.top),
-                MIN_HEIGHT
-            );
+            retBox.height = Math.max(elementBox.height - (retBox.top - elementBox.top), MIN_HEIGHT);
         }
-
-        if (
-            this.boxDirections.left &&
-            elementBox.left < targetBox.left + this.pad
-        ) {
+        if (this.boxDirections.left &&
+            elementBox.left < targetBox.left + this.pad) {
             retBox.left = targetBox.left + this.pad;
-            retBox.width = Math.max(
-                elementBox.width - (retBox.left - elementBox.left),
-                MIN_WIDTH
-            );
+            retBox.width = Math.max(elementBox.width - (retBox.left - elementBox.left), MIN_WIDTH);
         }
-
-        if (
-            this.boxDirections.right &&
+        if (this.boxDirections.right &&
             elementBox.left + elementBox.width >
-                targetBox.left + targetBox.width - this.pad
-        ) {
+                targetBox.left + targetBox.width - this.pad) {
             retBox.right = targetBox.left + targetBox.width - this.pad;
-            retBox.width = Math.max(
-                retBox.right - (retBox.left || elementBox.left),
-                MIN_WIDTH
-            );
+            retBox.width = Math.max(retBox.right - (retBox.left || elementBox.left), MIN_WIDTH);
         }
-
-        if (
-            this.boxDirections.bottom &&
+        if (this.boxDirections.bottom &&
             elementBox.top + elementBox.height >
-                targetBox.top + targetBox.height - this.pad
-        ) {
+                targetBox.top + targetBox.height - this.pad) {
             retBox.bottom = targetBox.top + targetBox.height - this.pad;
-            retBox.height = Math.max(
-                retBox.bottom - (retBox.top || elementBox.top),
-                MIN_HEIGHT
-            );
+            retBox.height = Math.max(retBox.bottom - (retBox.top || elementBox.top), MIN_HEIGHT);
         }
-
         return retBox;
     }
 }
 class BoundingBoxTransformer extends Transformer {
     transform(targetBox, elementBox) {
         const retBox = {};
-
-        if (
-            this.boxDirections.top &&
-            elementBox.top < targetBox.top + this.pad
-        ) {
+        if (this.boxDirections.top &&
+            elementBox.top < targetBox.top + this.pad) {
             retBox.top = targetBox.top + this.pad;
         }
-
-        if (
-            this.boxDirections.left &&
-            elementBox.left < targetBox.left + this.pad
-        ) {
+        if (this.boxDirections.left &&
+            elementBox.left < targetBox.left + this.pad) {
             retBox.left = targetBox.left + this.pad;
         }
-
-        if (
-            this.boxDirections.right &&
+        if (this.boxDirections.right &&
             elementBox.left + elementBox.width >
-                targetBox.left + targetBox.width - this.pad
-        ) {
+                targetBox.left + targetBox.width - this.pad) {
             retBox.left =
                 targetBox.left + targetBox.width - elementBox.width - this.pad;
         }
-
-        if (
-            this.boxDirections.bottom &&
+        if (this.boxDirections.bottom &&
             elementBox.top + elementBox.height >
-                targetBox.top + targetBox.height - this.pad
-        ) {
+                targetBox.top + targetBox.height - this.pad) {
             retBox.top =
                 targetBox.top + targetBox.height - elementBox.height - this.pad;
         }
-
         return retBox;
     }
 }
-
 class InverseBoundingBoxTransformer extends Transformer {
     transform(targetBox, elementBox) {
         const retBox = {};
-
-        if (
-            this.boxDirections.left &&
-            targetBox.left - this.pad < elementBox.left
-        ) {
+        if (this.boxDirections.left &&
+            targetBox.left - this.pad < elementBox.left) {
             retBox.left = targetBox.left - this.pad;
         }
-
-        if (
-            this.boxDirections.right &&
+        if (this.boxDirections.right &&
             elementBox.left + elementBox.width <
-                targetBox.left + targetBox.width + this.pad
-        ) {
+                targetBox.left + targetBox.width + this.pad) {
             retBox.left =
                 targetBox.width + this.pad - elementBox.width + targetBox.left;
         }
-
-        if (
-            this.boxDirections.top &&
-            targetBox.top < elementBox.top + this.pad
-        ) {
+        if (this.boxDirections.top &&
+            targetBox.top < elementBox.top + this.pad) {
             retBox.top = targetBox.top - this.pad;
         }
-
-        if (
-            this.boxDirections.bottom &&
+        if (this.boxDirections.bottom &&
             elementBox.top + elementBox.height <
-                targetBox.top + targetBox.height + this.pad
-        ) {
+                targetBox.top + targetBox.height + this.pad) {
             retBox.top =
                 targetBox.height + this.pad - elementBox.height + targetBox.top;
         }
-
         return retBox;
     }
 }
-
 const TransformFunctions = {
     center(input, targetBox) {
         return Math.floor(input + (0.5 * targetBox.width));
@@ -236,7 +163,6 @@ const TransformFunctions = {
         return input + targetBox.height;
     },
 };
-
 export const Transformers = {
     top: TopTransformer,
     bottom: BottomTransFormer,
@@ -250,7 +176,6 @@ export const Transformers = {
     'inverse bounding box': InverseBoundingBoxTransformer,
     default: Transformer,
 };
-
 export function toTransformFunctions(value) {
     return TransformFunctions[value] || TransformFunctions.left;
 }

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

@@ -0,0 +1,35 @@
+export function isShadowRoot(node: any): boolean;
+export function getScrollableParent(elem: any, stopEl: any): any;
+export function getScrollableParentFromEventPath(eventPath: any): HTMLElement;
+export function isInDom(el: any): boolean;
+export function isScrolling(elem: any): boolean;
+export function isDomNode(obj: any): boolean;
+export function computeAbsPos(target: any): {
+    top: any;
+    left: any;
+};
+export function timeout(time: any): Promise<any>;
+export function containsScrollingElement(list: any): boolean;
+export function queryScrollableChildren(element: any): any;
+export function getPositionTarget(element: any): any;
+export function generateUniqueSelector(): string;
+export function normalizeElement(element: any): any;
+export function normalizePosition(element: any, overlay: any, nextIndex: any, target: any, alignWidth: any): {
+    element: any;
+    overlay: any;
+};
+export function requestAnimationFrameAsPromise(): Promise<any>;
+export function pxToInt(value: any): number;
+export function pxToFloat(value: any): number;
+export const POSITION_ATTR_NAME: "data-position-id";
+export const WindowManager: BrowserWindow;
+declare class BrowserWindow {
+    get window(): any;
+    _window: any;
+    mockWindow(value: any): void;
+    get documentElement(): any;
+    get MutationObserver(): any;
+    isWindow(element: any): boolean;
+}
+export {};
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../../modules/lightning/positionLibrary/util.js"],"names":[],"mappings":"AA6CA,iDAEC;AAqCD,iEAKC;AAED,8EAgBC;AAWD,0CAsBC;AAED,gDAEC;AAED,6CAEC;AAED;;;EAYC;AAED,iDAOC;AAED,6DAYC;AAED,2DAEC;AAED,qDAMC;AAGD,iDAEC;AAED,oDAQC;AAED;;;EA4BC;AAED,+DAKC;AAMD,4CAEC;AAED,8CAEC;AAlQD,oDAAqD;AAwCrD,0CAAiD;AAtCjD;IACI,kBAaC;IAVO,aAAqB;IAW7B,6BAGC;IACD,2BAGC;IAED,4BAEC;IAED,gCAOC;CACJ"}