@workday/canvas-kit-popup-stack 6.8.9 → 6.9.0-next.2

package/dist/commonjs/index.js

@@ -1,6 +1,13 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./lib/PopupStack"));
+__exportStar(require("./lib/PopupStack"), exports);

package/dist/commonjs/lib/PopupStack.d.ts

@@ -142,96 +142,6 @@ export declare function resetStack(): void;
  *
  * @param adapter The parts of the PopupStack that we want to override
  */
-export declare const createAdapter: (adapter: Partial<{
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-}>) => void;
+export declare const createAdapter: (adapter: Partial<typeof PopupStack>) => void;
 export {};
 //# sourceMappingURL=PopupStack.d.ts.map

package/dist/commonjs/lib/PopupStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PopupStack.d.ts","sourceRoot":"","sources":["../../../lib/PopupStack.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AASD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAO9D;AA0DD,UAAU,KAAK;IACb,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,WAAW,CAAC;IAC9B,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC,OAAO,UAAU,CAAC,CAAC;CACtC;AAwFD,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAmBH;;;;OAIG;;IAcH;;;;OAIG;;IASH;;;;;;;;;;;OAWG;;IA8BH;;;;;;;;;;OAUG;;IA4BH;;;;;;OAMG;;IAqBH;;;;OAIG;;IAaH;;;;;;;;;;;;;;OAcG;;CAsBJ,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,SAEzB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;IAtQxB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAmBH;;;;OAIG;;IAcH;;;;OAIG;;IASH;;;;;;;;;;;OAWG;;IA8BH;;;;;;;;;;OAUG;;IA4BH;;;;;;OAMG;;IAqBH;;;;OAIG;;IAaH;;;;;;;;;;;;;;OAcG;;WAsCJ,CAAC"}
+{"version":3,"file":"PopupStack.d.ts","sourceRoot":"","sources":["../../../lib/PopupStack.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AASD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAO9D;AAyDD,UAAU,KAAK;IACb,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,WAAW,CAAC;IAC9B,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC,OAAO,UAAU,CAAC,CAAC;CACtC;AAwFD,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;uBACgB,WAAW;IAS9B;;;;;OAKG;cACO,cAAc,GAAG,IAAI;IAY/B;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI;IAkBlC;;;;OAIG;uBACgB,WAAW,GAAG,OAAO;IAaxC;;;;OAIG;oDACiC,WAAW,EAAE;IAQjD;;;;;;;;;;;OAWG;wBACiB,WAAW,GAAG,IAAI;IA6BtC;;;;;;;;;;OAUG;sBACe,WAAW,eAAe,WAAW,GAAG,OAAO;IA2BjE;;;;;;OAMG;gCACyB,WAAW,GAAG,IAAI;IAoB9C;;;;OAIG;+BACwB,WAAW,GAAG,IAAI;IAY7C;;;;;;;;;;;;;;OAcG;mCAC4B,cAAc,GAAG,IAAI;CAqBrD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,SAEzB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,YAAa,QAAQ,iBAAiB,CAAC,SAEhE,CAAC"}

package/dist/commonjs/lib/PopupStack.js

@@ -10,6 +10,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = exports.resetStack = exports.PopupStack = exports.getValue = void 0;
 var screenfull_1 = __importDefault(require("screenfull"));
 function getLast(items) {
     if (items.length) {
@@ -32,7 +33,7 @@ function getValue(index, length) {
 }
 exports.getValue = getValue;
 // IE11 doesn't support Array.prototype.find, so we'll polyfill here
-function find(items, predicate, thisArg) {
+function find(items, predicate) {
     var length = items.length;
     for (var i = 0; i < length; i++) {
         if (predicate(items[i], i, items)) {
@@ -397,9 +398,10 @@ exports.resetStack = resetStack;
  *
  * @param adapter The parts of the PopupStack that we want to override
  */
-exports.createAdapter = function (adapter) {
+var createAdapter = function (adapter) {
     stack._adapter = adapter;
 };
+exports.createAdapter = createAdapter;
 // keep track of the element ourselves to avoid accidentally popping off someone else's stack
 // context
 var element = null;

package/dist/es6/lib/PopupStack.d.ts

@@ -142,96 +142,6 @@ export declare function resetStack(): void;
  *
  * @param adapter The parts of the PopupStack that we want to override
  */
-export declare const createAdapter: (adapter: Partial<{
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-}>) => void;
+export declare const createAdapter: (adapter: Partial<typeof PopupStack>) => void;
 export {};
 //# sourceMappingURL=PopupStack.d.ts.map

package/dist/es6/lib/PopupStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PopupStack.d.ts","sourceRoot":"","sources":["../../../lib/PopupStack.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AASD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAO9D;AA0DD,UAAU,KAAK;IACb,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,WAAW,CAAC;IAC9B,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC,OAAO,UAAU,CAAC,CAAC;CACtC;AAwFD,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAmBH;;;;OAIG;;IAcH;;;;OAIG;;IASH;;;;;;;;;;;OAWG;;IA8BH;;;;;;;;;;OAUG;;IA4BH;;;;;;OAMG;;IAqBH;;;;OAIG;;IAaH;;;;;;;;;;;;;;OAcG;;CAsBJ,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,SAEzB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;IAtQxB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAmBH;;;;OAIG;;IAcH;;;;OAIG;;IASH;;;;;;;;;;;OAWG;;IA8BH;;;;;;;;;;OAUG;;IA4BH;;;;;;OAMG;;IAqBH;;;;OAIG;;IAaH;;;;;;;;;;;;;;OAcG;;WAsCJ,CAAC"}
+{"version":3,"file":"PopupStack.d.ts","sourceRoot":"","sources":["../../../lib/PopupStack.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB;AASD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAO9D;AAyDD,UAAU,KAAK;IACb,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,WAAW,CAAC;IAC9B,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,QAAQ,EAAE,OAAO,CAAC,OAAO,UAAU,CAAC,CAAC;CACtC;AAwFD,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;uBACgB,WAAW;IAS9B;;;;;OAKG;cACO,cAAc,GAAG,IAAI;IAY/B;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI;IAkBlC;;;;OAIG;uBACgB,WAAW,GAAG,OAAO;IAaxC;;;;OAIG;oDACiC,WAAW,EAAE;IAQjD;;;;;;;;;;;OAWG;wBACiB,WAAW,GAAG,IAAI;IA6BtC;;;;;;;;;;OAUG;sBACe,WAAW,eAAe,WAAW,GAAG,OAAO;IA2BjE;;;;;;OAMG;gCACyB,WAAW,GAAG,IAAI;IAoB9C;;;;OAIG;+BACwB,WAAW,GAAG,IAAI;IAY7C;;;;;;;;;;;;;;OAcG;mCAC4B,cAAc,GAAG,IAAI;CAqBrD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,SAEzB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,YAAa,QAAQ,iBAAiB,CAAC,SAEhE,CAAC"}

package/dist/es6/lib/PopupStack.js

@@ -26,7 +26,7 @@ export function getValue(index, length) {
     return Math.max(min, max - (length - index) + 1);
 }
 // IE11 doesn't support Array.prototype.find, so we'll polyfill here
-function find(items, predicate, thisArg) {
+function find(items, predicate) {
     var length = items.length;
     for (var i = 0; i < length; i++) {
         if (predicate(items[i], i, items)) {

package/lib/PopupStack.ts

@@ -53,8 +53,7 @@ export function getValue(index: number, length: number): number {
 // IE11 doesn't support Array.prototype.find, so we'll polyfill here
 function find<T>(
   items: T[],
-  predicate: (value: T, index: number, obj: T[]) => boolean,
-  thisArg?: any
+  predicate: (value: T, index: number, obj: T[]) => boolean
 ): T | undefined {
   const length = items.length;
   for (let i = 0; i < length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workday/canvas-kit-popup-stack",
-  "version": "6.8.9",
+  "version": "6.9.0-next.2+8dd3d6b6",
   "description": "Stack for managing popup UIs to coordinate global concerns like escape key handling and rendering order",
   "author": "Workday, Inc. (https://www.workday.com)",
   "license": "Apache-2.0",
@@ -10,29 +10,21 @@
   "types": "dist/es6/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Workday/canvas-kit/tree/master/modules/popup-stack"
+    "url": "https://github.com/workday/canvas-kit.git",
+    "directory": "modules/popup-stack"
   },
   "files": [
     "dist/",
     "lib/",
-    "index.ts",
-    "ts3.5/**/*"
+    "index.ts"
   ],
-  "typesVersions": {
-    "<=3.5": {
-      "*": [
-        "ts3.5/*"
-      ]
-    }
-  },
   "scripts": {
     "watch": "yarn build:es6 -w",
-    "clean": "rimraf dist && rimraf ts3.5 && rimraf .build-info && mkdirp dist && mkdirp ts3.5/dist",
+    "clean": "rimraf dist && rimraf .build-info && mkdirp dist",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:es6": "tsc -p tsconfig.es6.json",
     "build:rebuild": "npm-run-all clean build",
-    "build:downlevel-dts": "yarn run downlevel-dts dist ts3.5/dist",
-    "build": "npm-run-all --parallel build:cjs build:es6 --sequential build:downlevel-dts",
+    "build": "npm-run-all --parallel build:cjs build:es6",
     "depcheck": "node ../../utils/check-dependencies-exist.js",
     "typecheck:src": "tsc -p . --noEmit --incremental false"
   },
@@ -45,5 +37,5 @@
   "dependencies": {
     "screenfull": "^5.2.0"
   },
-  "gitHead": "9616dcc6b1b17b48a2463a29b3db49b55708ee5b"
+  "gitHead": "8dd3d6b6d1af27a68d8ee952ad70a389a0b675dd"
 }

package/ts3.5/dist/commonjs/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lib/PopupStack';
-//# sourceMappingURL=index.d.ts.map

package/ts3.5/dist/commonjs/lib/PopupStack.d.ts

@@ -1,237 +0,0 @@
-/**
- * This type is purposely an interface so that it can be extended for a specific use-case.
- */
-export interface PopupStackItem {
-    /**
-     * All items in the stack are identified by their DOM element reference. A DOM element is
-     * framework agnostic.
-     */
-    element: HTMLElement;
-    /**
-     * An owner is typically a trigger or anchor target. For example, it will be a HTMLButtonElement
-     * that opened a dropdown menu. If an owner is provided, _and_ that owner element is part of
-     * another stack item, it will be considered a "parent" of the provided stack item. This reference
-     * helps in the following ways:
-     * - Click outside detection typically will use `PopupStack.contains()` which includes this
-     *   element. If you wish to close a popup when the target is clicked, add a click handler to do
-     *   so.
-     * - `PopupStack.bringToTop()` will also bring children to top as well using the `owner` reference
-     *   to map a "child" popup back to its parent. This is useful for "Window" or other persistent
-     *   popups that are brought to the front when clicked. This will prevent the "Window" from
-     *   rendering on top of child popups as they will be brought along also.
-     * - Synthetic event systems like in React will bubble events through "portals". This is
-     *   inconsistent with DOM event bubbling. This reference helps normalize that behavior across
-     *   different frameworks.
-     */
-    owner?: HTMLElement;
-}
-/**
- * Calculate the zIndex value of a given index in the stack. The range is 20 where 30 is the minimum
- * and 50 is the maximum. If there are more than 20 items in the stack, we'll have multiple zIndexes
- * of 30 at the bottom of the stack since the user probably can't tell the difference with that many
- * popups.
- */
-export declare function getValue(index: number, length: number): number;
-interface Stack {
-    items: PopupStackItem[];
-    container?: () => HTMLElement;
-    zIndex: {
-        min: number;
-        max: number;
-        getValue: typeof getValue;
-    };
-    _adapter: Partial<typeof PopupStack>;
-}
-export declare const PopupStack: {
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-};
-/**
- * Reset all the items in the stack. This should only be used for testing or if the page doesn't
- * properly tear down each item in the stack when switching views.
- */
-export declare function resetStack(): void;
-/**
- *
- * @param adapter The parts of the PopupStack that we want to override
- */
-export declare const createAdapter: (adapter: Partial<{
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-}>) => void;
-export {};
-//# sourceMappingURL=PopupStack.d.ts.map

package/ts3.5/dist/es6/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lib/PopupStack';
-//# sourceMappingURL=index.d.ts.map

package/ts3.5/dist/es6/lib/PopupStack.d.ts

@@ -1,237 +0,0 @@
-/**
- * This type is purposely an interface so that it can be extended for a specific use-case.
- */
-export interface PopupStackItem {
-    /**
-     * All items in the stack are identified by their DOM element reference. A DOM element is
-     * framework agnostic.
-     */
-    element: HTMLElement;
-    /**
-     * An owner is typically a trigger or anchor target. For example, it will be a HTMLButtonElement
-     * that opened a dropdown menu. If an owner is provided, _and_ that owner element is part of
-     * another stack item, it will be considered a "parent" of the provided stack item. This reference
-     * helps in the following ways:
-     * - Click outside detection typically will use `PopupStack.contains()` which includes this
-     *   element. If you wish to close a popup when the target is clicked, add a click handler to do
-     *   so.
-     * - `PopupStack.bringToTop()` will also bring children to top as well using the `owner` reference
-     *   to map a "child" popup back to its parent. This is useful for "Window" or other persistent
-     *   popups that are brought to the front when clicked. This will prevent the "Window" from
-     *   rendering on top of child popups as they will be brought along also.
-     * - Synthetic event systems like in React will bubble events through "portals". This is
-     *   inconsistent with DOM event bubbling. This reference helps normalize that behavior across
-     *   different frameworks.
-     */
-    owner?: HTMLElement;
-}
-/**
- * Calculate the zIndex value of a given index in the stack. The range is 20 where 30 is the minimum
- * and 50 is the maximum. If there are more than 20 items in the stack, we'll have multiple zIndexes
- * of 30 at the bottom of the stack since the user probably can't tell the difference with that many
- * popups.
- */
-export declare function getValue(index: number, length: number): number;
-interface Stack {
-    items: PopupStackItem[];
-    container?: () => HTMLElement;
-    zIndex: {
-        min: number;
-        max: number;
-        getValue: typeof getValue;
-    };
-    _adapter: Partial<typeof PopupStack>;
-}
-export declare const PopupStack: {
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-};
-/**
- * Reset all the items in the stack. This should only be used for testing or if the page doesn't
- * properly tear down each item in the stack when switching views.
- */
-export declare function resetStack(): void;
-/**
- *
- * @param adapter The parts of the PopupStack that we want to override
- */
-export declare const createAdapter: (adapter: Partial<{
-    /**
-     * Create a HTMLElement as the container for the popup stack item. The returned element reference
-     * will be the reference to be passed to all other methods. The Popup Stack will control when this
-     * element is added and removed from the DOM as well as the `z-index` style property. Your content
-     * should be added to this element.
-     */
-    createContainer(): HTMLElement;
-    /**
-     * Adds a PopupStackItem to the stack. This should only be called when the item is rendered to the
-     * page. Z-indexes are set when the item is added to the stack. If your application requires
-     * popups to be registered initially, but rendered when the user triggers some event, call this
-     * method when the event triggers.
-     */
-    add(item: PopupStackItem): void;
-    /**
-     * Removes an item from a stack by its `HTMLElement` reference. This should be called when a popup
-     * is "closed" or when the element is removed from the page entirely to ensure proper memory
-     * cleanup. A popup will be removed from the stack it is a part of. This will not automatically be
-     * called when the element is removed from the DOM. This method will reset z-index values of the
-     * stack.
-     */
-    remove(element: HTMLElement): void;
-    /**
-     * Returns true when the provided `element` is at the top of the stack. It will return false if it
-     * is not the top of the stack or is not found in the stack. The `element` should be the same
-     * reference that was passed to `add`
-     */
-    isTopmost(element: HTMLElement): boolean;
-    /**
-     * Returns an array of elements defined by the `element` passed to `add`. This method return
-     * elements in the order of lowest z-index to highest z-index. Some popup behaviors will need to
-     * make decisions based on z-index order.
-     */
-    getElements(stackOverride?: Stack | undefined): HTMLElement[];
-    /**
-     * Bring the element to the top of the stack. This is useful for persistent popups to place them
-     * on top of the stack when clicked. If an `owner` was provided to an item when it was added and
-     * that owner is a DOM child of another item in the stack, that item will be considered a "parent"
-     * to this item. If the previous are true, all "children" stack items will be brought to top as
-     * well and will be on top of the element passed to `bringToTop`. This maintains stack item
-     * "hierarchy" so that stack items like Popups and Tooltips don't get pushed behind elements they
-     * are supposed to be on top of.
-     *
-     * This does not need to be called when a popup is added since added popups are already place on
-     * the top of the stack.
-     */
-    bringToTop(element: HTMLElement): void;
-    /**
-     * Compares a Popup by its element reference against the event target and the stack. An event
-     * target is considered to be "contained" by an element under the following conditions:
-     * - The `eventTarget` is a DOM child of the popup element
-     * - The `eventTarget` is the `owner` element passed when it was added to the stack
-     * - The `eventTarget` is a DOM child of the `owner` element
-     *
-     * This method should be used instead of `element.contains` so that clicking a popup target can
-     * opt-in to toggling. Otherwise there is no way to opt-out of toggle behavior (because the target
-     * is not inside `element`).
-     */
-    contains(element: HTMLElement, eventTarget: HTMLElement): boolean;
-    /**
-     * Add a new stack context for popups. This method could be called with the same element multiple
-     * times, but should only push a new stack context once. The most common use-case for calling
-     * `pushStackContext` is when entering fullscreen, but multiple fullscreen listeners could be
-     * pushing the same element which is very difficult to ensure only one stack is used. To mitigate,
-     * this method filters out multiple calls to push the same element as a new stack context.
-     */
-    pushStackContext(container: HTMLElement): void;
-    /**
-     * Remove the topmost stack context. The stack context will only be removed if the top stack
-     * context container element matches to guard against accidental remove of other stack contexts
-     * you don't own.
-     */
-    popStackContext(container: HTMLElement): void;
-    /**
-     * Transfer the popup stack item into the current popup stack context.
-     *
-     * An example might be a popup
-     * that is opened and an element goes into fullscreen. The default popup stack context is
-     * `document.body`, but the [Fullscreen
-     * API](https://developer.mozilla.org/en-US/docs/Web/API/Fullscreen_API) will only render elements
-     * that are children of the fullscreen element. If the popup isn't transferred to the current
-     * popup stack context, the popup will remain open, but will no longer be rendered. This method
-     * will transfer that popup to the fullscreen element so that it will render. Popups created while
-     * in a fullscreen context that need to be transferred back when fullscreen is exited should also
-     * call this method. While popups may still render when fullscreen is exited, popups will be
-     * members of different popup stack contexts which will cause unspecified results (like the escape
-     * key will choose the wrong popup as the "topmost").
-     */
-    transferToCurrentContext(item: PopupStackItem): void;
-}>) => void;
-export {};
-//# sourceMappingURL=PopupStack.d.ts.map