@workday/canvas-kit-popup-stack 7.0.0-alpha.0-next.3 → 7.0.0-alpha.0-next.7

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;;IAgBH;;;;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;IAnQxB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAgBH;;;;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;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;uBACgB,WAAW;IAS9B;;;;;OAKG;cACO,cAAc,GAAG,IAAI;IAY/B;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI;IAelC;;;;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) {
@@ -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;;IAgBH;;;;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;IAnQxB;;;;;OAKG;;IAUH;;;;;OAKG;;IAaH;;;;;;OAMG;;IAgBH;;;;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;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;uBACgB,WAAW;IAS9B;;;;;OAKG;cACO,cAAc,GAAG,IAAI;IAY/B;;;;;;OAMG;oBACa,WAAW,GAAG,IAAI;IAelC;;;;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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workday/canvas-kit-popup-stack",
-  "version": "7.0.0-alpha.0-next.3+14a81c7e",
+  "version": "7.0.0-alpha.0-next.7+23568685",
   "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",
@@ -45,5 +45,5 @@
   "dependencies": {
     "screenfull": "^5.2.0"
   },
-  "gitHead": "14a81c7ef3deb9efaf67fa3ec9cc2d2a3161b00b"
+  "gitHead": "23568685fec785046d37cb320289d8ab9e74e283"
 }

package/ts3.5/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/ts3.5/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