@sebgroup/green-core 1.69.4 → 1.70.1

package/components/coachmark/coachmark.component.js

@@ -0,0 +1,287 @@
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "../../chunks/chunk.QTSIPXV3.js";
+var _cardRef, _arrowRef, _autoUpdateCleanupFn, _closeCoachMark, closeCoachMark_fn, _findTarget, findTarget_fn, _checkBoundingRect, checkBoundingRect_fn, _checkOverlap, checkOverlap_fn, _isElementOutsideView, isElementOutsideView_fn, _computeTooltipPosition, computeTooltipPosition_fn, _shouldTooltipBeVisible, shouldTooltipBeVisible_fn, _updateCoachmarks, updateCoachmarks_fn;
+import { property, state } from "lit/decorators.js";
+import { createRef, ref } from "lit/directives/ref.js";
+import { when } from "lit/directives/when.js";
+import {
+  arrow,
+  autoUpdate,
+  computePosition,
+  detectOverflow,
+  flip,
+  hide,
+  offset,
+  shift
+} from "@floating-ui/dom";
+import { GdsElement } from "../../gds-element";
+import { gdsCustomElement, html } from "../../scoping";
+import styles from "./coachmark.styles";
+let GdsCoachmark = class extends GdsElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _closeCoachMark);
+    __privateAdd(this, _findTarget);
+    __privateAdd(this, _checkBoundingRect);
+    __privateAdd(this, _checkOverlap);
+    __privateAdd(this, _isElementOutsideView);
+    __privateAdd(this, _computeTooltipPosition);
+    __privateAdd(this, _shouldTooltipBeVisible);
+    __privateAdd(this, _updateCoachmarks);
+    this.placement = "bottom";
+    this.overlappedBy = [];
+    this.target = [];
+    this.label = "Coachmark";
+    this.computeVisibility = (_self, _target, computedVisibility) => computedVisibility;
+    /**
+     * The resolved targeted element (readonly)
+     */
+    this.targetElement = void 0;
+    this._isVisible = false;
+    this._preventClose = false;
+    __privateAdd(this, _cardRef, createRef());
+    __privateAdd(this, _arrowRef, createRef());
+    __privateAdd(this, _autoUpdateCleanupFn, void 0);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    document.addEventListener("click", () => {
+      setTimeout(() => {
+        __privateMethod(this, _updateCoachmarks, updateCoachmarks_fn).call(this);
+        __privateMethod(this, _closeCoachMark, closeCoachMark_fn).call(this);
+      }, 400);
+    });
+    document.addEventListener("keydown", (event) => {
+      if (event.key === "Escape" && this._isVisible) {
+        __privateMethod(this, _closeCoachMark, closeCoachMark_fn).call(this);
+      }
+    });
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    document.removeEventListener("click", __privateMethod(this, _closeCoachMark, closeCoachMark_fn));
+    document.removeEventListener("keydown", (event) => {
+      if (event.key === "Escape" && this._isVisible) {
+        __privateMethod(this, _closeCoachMark, closeCoachMark_fn).call(this);
+      }
+    });
+  }
+  firstUpdated() {
+    if (this.target.length > 0) {
+      this.targetElement = __privateMethod(this, _findTarget, findTarget_fn).call(this, this.target);
+      __privateMethod(this, _updateCoachmarks, updateCoachmarks_fn).call(this);
+    }
+  }
+  setPreventClose(preventClose) {
+    this._preventClose = preventClose;
+  }
+  render() {
+    return html`${when(
+      this.target.length > 0,
+      () => html`
+        <div
+          role="dialog"
+          id="body"
+          aria-label=${this.label}
+          ${ref(__privateGet(this, _cardRef))}
+        >
+          <slot></slot>
+          <div id="arrow" ${ref(__privateGet(this, _arrowRef))}></div>
+        </div>
+      `,
+      () => html``
+    )}`;
+  }
+};
+_cardRef = new WeakMap();
+_arrowRef = new WeakMap();
+_autoUpdateCleanupFn = new WeakMap();
+_closeCoachMark = new WeakSet();
+closeCoachMark_fn = function() {
+  var _a;
+  if (!this._isVisible)
+    return;
+  this._isVisible = false;
+  __privateGet(this, _cardRef).value?.remove();
+  (_a = __privateGet(this, _autoUpdateCleanupFn)) == null ? void 0 : _a.call(this);
+  this.dispatchEvent(
+    new CustomEvent("gds-ui-state", {
+      detail: { open: this._isVisible, reason: "closed" },
+      bubbles: false,
+      composed: false
+    })
+  );
+};
+_findTarget = new WeakSet();
+findTarget_fn = function(selectors) {
+  let shadow = false;
+  let el = void 0;
+  for (const selector of selectors) {
+    if (selector === "shadowRoot") {
+      shadow = true;
+      continue;
+    }
+    if (!el) {
+      el = document.querySelector(selector);
+    } else if (shadow && el.shadowRoot) {
+      el = el.shadowRoot.querySelector(selector);
+      shadow = false;
+    } else {
+      el = el.querySelector(selector);
+    }
+  }
+  return el;
+};
+_checkBoundingRect = new WeakSet();
+checkBoundingRect_fn = function(element, overlappedElement) {
+  if (element == overlappedElement)
+    return;
+  const elementRect = element.getBoundingClientRect();
+  const overlappedElementRect = overlappedElement.getBoundingClientRect();
+  return elementRect.top < overlappedElementRect.bottom && elementRect.bottom > overlappedElementRect.top && elementRect.left < overlappedElementRect.right && elementRect.right > overlappedElementRect.left;
+};
+_checkOverlap = new WeakSet();
+checkOverlap_fn = function(selectors) {
+  if (!selectors)
+    return false;
+  for (const selector of selectors) {
+    const el = document.querySelector(selector);
+    if (!el || getComputedStyle(el).visibility === "hidden")
+      continue;
+    if (__privateMethod(this, _checkBoundingRect, checkBoundingRect_fn).call(this, this.targetElement, el)) {
+      return true;
+    }
+  }
+  return false;
+};
+_isElementOutsideView = new WeakSet();
+isElementOutsideView_fn = function(element) {
+  const elementRect = element.getBoundingClientRect();
+  const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+  const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+  return elementRect.top + elementRect.height < 0 || elementRect.top > windowHeight || elementRect.left + elementRect.width < 0 || elementRect.left > windowWidth;
+};
+_computeTooltipPosition = new WeakSet();
+computeTooltipPosition_fn = async function(targetedEl, componentEl, arrowEl) {
+  return computePosition(targetedEl, componentEl, {
+    placement: this.placement,
+    middleware: [
+      offset(() => ({
+        mainAxis: 16,
+        alignmentAxis: 16
+      })),
+      {
+        name: "detectOverflow",
+        async fn(positionState) {
+          const overflow = await detectOverflow(positionState, {
+            boundary: document.body,
+            rootBoundary: "document",
+            altBoundary: true,
+            padding: {
+              top: 167,
+              left: 20
+            }
+          });
+          return {
+            data: overflow
+          };
+        }
+      },
+      shift({ padding: 16 }),
+      flip(),
+      hide(),
+      arrow({
+        padding: 16,
+        element: arrowEl
+      })
+    ]
+  });
+};
+_shouldTooltipBeVisible = new WeakSet();
+shouldTooltipBeVisible_fn = function() {
+  if (!this.targetElement)
+    return false;
+  const isOutOfBound = __privateMethod(this, _isElementOutsideView, isElementOutsideView_fn).call(this, this.targetElement);
+  const targetIsVisible = this.targetElement.checkVisibility();
+  const isOverlapping = this.overlappedBy.length === 0 ? false : __privateMethod(this, _checkOverlap, checkOverlap_fn).call(this, this.overlappedBy);
+  return this.computeVisibility(
+    this,
+    this.targetElement,
+    !isOverlapping && !isOutOfBound && targetIsVisible
+  );
+};
+_updateCoachmarks = new WeakSet();
+updateCoachmarks_fn = async function() {
+  const targetEl = this.targetElement;
+  const componentEl = __privateGet(this, _cardRef).value;
+  const arrowEl = __privateGet(this, _arrowRef).value;
+  if (!targetEl || !componentEl || !arrowEl)
+    return;
+  try {
+    __privateSet(this, _autoUpdateCleanupFn, autoUpdate(targetEl, componentEl, () => {
+      __privateMethod(this, _computeTooltipPosition, computeTooltipPosition_fn).call(this, targetEl, componentEl, arrowEl).then(
+        ({ x, y, middlewareData, placement }) => {
+          if (__privateMethod(this, _shouldTooltipBeVisible, shouldTooltipBeVisible_fn).call(this)) {
+            this._isVisible = true;
+            Object.assign(componentEl.style, {
+              visibility: "visible",
+              opacity: 1,
+              left: `${x}px`,
+              top: `${y}px`
+            });
+            if (middlewareData.arrow) {
+              const { x: x2, y: y2 } = middlewareData.arrow;
+              arrowEl.removeAttribute("class");
+              arrowEl.classList.add("arrow-" + placement);
+              Object.assign(arrowEl.style, {
+                left: x2 != null ? `${x2}px` : "",
+                top: y2 != null ? `${y2}px` : ""
+              });
+            }
+          } else {
+            this._isVisible = false;
+            Object.assign(componentEl.style, {
+              visibility: "hidden",
+              opacity: 0
+            });
+          }
+        }
+      );
+    }));
+  } catch (error) {
+    console.warn("failed to render tooltips");
+  }
+};
+GdsCoachmark.styles = styles;
+__decorateClass([
+  property()
+], GdsCoachmark.prototype, "placement", 2);
+__decorateClass([
+  property({ attribute: false })
+], GdsCoachmark.prototype, "overlappedBy", 2);
+__decorateClass([
+  property({ attribute: false })
+], GdsCoachmark.prototype, "target", 2);
+__decorateClass([
+  property()
+], GdsCoachmark.prototype, "label", 2);
+__decorateClass([
+  property({ attribute: false })
+], GdsCoachmark.prototype, "computeVisibility", 2);
+__decorateClass([
+  state()
+], GdsCoachmark.prototype, "_isVisible", 2);
+__decorateClass([
+  state()
+], GdsCoachmark.prototype, "_preventClose", 2);
+GdsCoachmark = __decorateClass([
+  gdsCustomElement("gds-coachmark")
+], GdsCoachmark);
+export {
+  GdsCoachmark
+};

package/components/coachmark/coachmark.d.ts

@@ -1,52 +1,2 @@
-import { Placement } from '@floating-ui/dom';
-import { GdsElement } from '../../gds-element';
-/**
- * @element gds-coachmark
- * A tooltip container with a slot and an arrow pointing towards the targeted element
- * depending on the preferred placement,
- * the coachmark is hidden/disabled when the element is overlapped or out of viewport.
- *
- * @slot - placeholder for the content of the tooltip.
- *
- * @event gds-ui-state - dispatched when the tooltip is closed
- *
- * @status beta
- */
-export declare class GdsCoachmark extends GdsElement {
-    #private;
-    static styles: import("lit").CSSResult;
-    /**
-     * The placement of the popover relative to the trigger.
-     * Accepts any of the placements supported by Floating UI.
-     */
-    placement: Placement;
-    /**
-     * The coachmark will be hidden when overlapped by the list of provided elements (selectors).
-     */
-    overlappedBy: string[];
-    /**
-     * List of selectors pointing to the targeted element. Ex. for a target inside a ShadowDOM: ["some-component", "shadowRoot", "target-element"].
-     */
-    target: string[];
-    /**
-     * The accessible label of the coachmark.
-     */
-    label: string;
-    /**
-     * A callback that can be used to set the visibility of the coachmark based on your criteria.
-     *
-     * The default computed visibility, based on visibility and overlap of the target element, is supplied as the third argument.
-     */
-    computeVisibility: (self: GdsCoachmark, target: HTMLElement, computedVisibility: boolean) => boolean;
-    /**
-     * The resolved targeted element (readonly)
-     */
-    targetElement: HTMLElement | undefined;
-    _isVisible: boolean;
-    _preventClose: boolean;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    firstUpdated(): void;
-    setPreventClose(preventClose: boolean): void;
-    render(): any;
-}
+import { GdsCoachmark } from './coachmark.component';
+export { GdsCoachmark };

package/components/coachmark/coachmark.js

@@ -1,11 +1,6 @@
-import {
-  GdsCoachmark
-} from "../../chunks/chunk.XOR75GI6.js";
-import "../../chunks/chunk.YO24ZYAD.js";
-import "../../chunks/chunk.TMEWQZER.js";
-import "../../chunks/chunk.QK3R23GV.js";
-import "../../chunks/chunk.B7ZOSVCQ.js";
-import "../../chunks/chunk.SEHSDSX2.js";
+import "../../chunks/chunk.QTSIPXV3.js";
+import { GdsCoachmark } from "./coachmark.component";
+GdsCoachmark.define();
 export {
   GdsCoachmark
 };

package/components/coachmark/coachmark.styles.js

@@ -0,0 +1,55 @@
+import "../../chunks/chunk.QTSIPXV3.js";
+import { css } from "lit";
+const style = css`
+  #body {
+    visibility: hidden;
+    position: absolute;
+    z-index: 1060;
+    box-sizing: border-box;
+    padding: 1rem;
+    width: 20rem;
+    border-radius: 0.25rem;
+    background-color: #222;
+    color: #fff;
+    opacity: 0;
+    transition: opacity 0.3s;
+  }
+
+  #arrow {
+    box-sizing: border-box;
+    z-index: -1;
+    position: absolute;
+    height: 1rem;
+    width: 1rem;
+    background-color: #222;
+    transform: rotate(45deg);
+  }
+
+  .arrow-top,
+  .arrow-top-start,
+  .arrow-top-end {
+    bottom: -0.5rem;
+  }
+
+  .arrow-bottom,
+  .arrow-bottom-start,
+  .arrow-bottom-end {
+    top: -0.5rem;
+  }
+
+  .arrow-left,
+  .arrow-left-start,
+  .arrow-left-end {
+    right: -0.5rem;
+  }
+
+  .arrow-right,
+  .arrow-right-start,
+  .arrow-right-end {
+    left: -0.5rem;
+  }
+`;
+var coachmark_styles_default = style;
+export {
+  coachmark_styles_default as default
+};

package/components/coachmark/index.js

@@ -1,11 +1 @@
-import {
-  GdsCoachmark
-} from "../../chunks/chunk.XOR75GI6.js";
-import "../../chunks/chunk.YO24ZYAD.js";
-import "../../chunks/chunk.TMEWQZER.js";
-import "../../chunks/chunk.QK3R23GV.js";
-import "../../chunks/chunk.B7ZOSVCQ.js";
-import "../../chunks/chunk.SEHSDSX2.js";
-export {
-  GdsCoachmark
-};
+export * from "./coachmark";

package/components/container/container.component.d.ts

@@ -0,0 +1,8 @@
+import { GdsDiv } from '../div/div.component';
+/**
+ * @element gds-container
+ * @status beta
+ * @deprecated `gds-container` is an alias for `gds-div`. Prefer using `gds-div` directly instead.
+ */
+export declare class GdsContainer extends GdsDiv {
+}

package/components/container/container.component.js

@@ -0,0 +1,13 @@
+import {
+  __decorateClass
+} from "../../chunks/chunk.QTSIPXV3.js";
+import { gdsCustomElement } from "../../scoping";
+import { GdsDiv } from "../div/div.component";
+let GdsContainer = class extends GdsDiv {
+};
+GdsContainer = __decorateClass([
+  gdsCustomElement("gds-container")
+], GdsContainer);
+export {
+  GdsContainer
+};

package/components/container/container.d.ts

@@ -1,8 +1,2 @@
-import { GdsDiv } from '../div';
-/**
- * @element gds-container
- * @status beta
- * @deprecated `gds-container` is an alias for `gds-div`. Prefer using `gds-div` directly instead.
- */
-export declare class GdsContainer extends GdsDiv {
-}
+import { GdsContainer } from './container.component';
+export { GdsContainer };

package/components/container/container.js

@@ -1,18 +1,6 @@
-import {
-  GdsContainer
-} from "../../chunks/chunk.PKXNP4H4.js";
-import "../../chunks/chunk.M5C2HLKD.js";
-import "../../chunks/chunk.UZJIO4LE.js";
-import "../../chunks/chunk.TWXTKG4B.js";
-import "../../chunks/chunk.76QWARGM.js";
-import "../../chunks/chunk.NUUST5OZ.js";
-import "../../chunks/chunk.HEZEUVHT.js";
-import "../../chunks/chunk.6QMJ7GQK.js";
-import "../../chunks/chunk.YO24ZYAD.js";
-import "../../chunks/chunk.TMEWQZER.js";
-import "../../chunks/chunk.QK3R23GV.js";
-import "../../chunks/chunk.B7ZOSVCQ.js";
-import "../../chunks/chunk.SEHSDSX2.js";
+import "../../chunks/chunk.QTSIPXV3.js";
+import { GdsContainer } from "./container.component";
+GdsContainer.define();
 export {
   GdsContainer
 };

package/components/container/index.js

@@ -1,19 +1 @@
-import "../../chunks/chunk.WFKUYHQY.js";
-import {
-  GdsContainer
-} from "../../chunks/chunk.PKXNP4H4.js";
-import "../../chunks/chunk.M5C2HLKD.js";
-import "../../chunks/chunk.UZJIO4LE.js";
-import "../../chunks/chunk.TWXTKG4B.js";
-import "../../chunks/chunk.76QWARGM.js";
-import "../../chunks/chunk.NUUST5OZ.js";
-import "../../chunks/chunk.HEZEUVHT.js";
-import "../../chunks/chunk.6QMJ7GQK.js";
-import "../../chunks/chunk.YO24ZYAD.js";
-import "../../chunks/chunk.TMEWQZER.js";
-import "../../chunks/chunk.QK3R23GV.js";
-import "../../chunks/chunk.B7ZOSVCQ.js";
-import "../../chunks/chunk.SEHSDSX2.js";
-export {
-  GdsContainer
-};
+export * from "./container";

package/components/context-menu/context-menu.component.d.ts

@@ -0,0 +1,47 @@
+import { Placement } from '@floating-ui/dom';
+import { GdsElement } from '../../gds-element';
+import { GdsMenuItem } from '../../primitives/menu/menu-item.component';
+export { GdsMenuItem };
+export { GdsMenuHeading } from '../../primitives/menu/menu-heading.component';
+declare const GdsContextMenu_base: (new (...args: any[]) => import("../../utils/mixins/declarative-layout-mixins").MarginProps) & (new (...args: any[]) => import("../../utils/mixins/declarative-layout-mixins").LayoutChildProps) & typeof GdsElement;
+/**
+ * @element gds-context-menu
+ * @status stable
+ *
+ * The context menu is presented in-context to the related data, so users don’t lose
+ * their place in the app. It appears upon interaction with the 3 dot button and
+ * displays a list of choices, one choice per line.
+ *
+ * @event gds-menu-item-click - Fired when a menu item is clicked.
+ * @event gds-ui-state - Fired when the menu is opened or closed.
+ *
+ * @slot - The default slot. Only `gds-menu-item` elements are accepted here.
+ */
+export declare class GdsContextMenu extends GdsContextMenu_base {
+    #private;
+    static styles: (import("lit").CSSResult | import("lit").CSSResult[])[];
+    static shadowRootOptions: ShadowRootInit;
+    /**
+     * Whether the context menu popover is open.
+     */
+    open: boolean;
+    /**
+     * The label for the trigger button.
+     */
+    buttonLabel: string;
+    /**
+     * Whether to show the label on the trigger button.
+     */
+    showLabel: boolean;
+    /**
+     * The label for the popover and menu. Should describe the context of the menu.
+     */
+    label: string;
+    /**
+     * The placement of the popover relative to the trigger.
+     */
+    placement: Placement;
+    private elTriggerBtn;
+    connectedCallback(): void;
+    render(): any;
+}

package/components/context-menu/context-menu.component.js

@@ -0,0 +1,137 @@
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod
+} from "../../chunks/chunk.QTSIPXV3.js";
+var _renderPopover, _handleItemClick, handleItemClick_fn;
+import { localized, msg } from "@lit/localize";
+import { nothing } from "lit";
+import { property, queryAsync } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { when } from "lit/directives/when.js";
+import { GdsElement } from "../../gds-element";
+import { GdsMenuItem } from "../../primitives/menu/menu-item.component";
+import { GdsMenu } from "../../primitives/menu/menu.component";
+import { tokens } from "../../tokens.style";
+import { TransitionalStyles } from "../../transitional-styles";
+import {
+  gdsCustomElement,
+  html
+} from "../../utils/helpers/custom-element-scoping";
+import {
+  withLayoutChildProps,
+  withMarginProps
+} from "../../utils/mixins/declarative-layout-mixins";
+import { GdsPopover } from "../popover/popover.component";
+import styles from "./context-menu.styles";
+import { GdsMenuHeading } from "../../primitives/menu/menu-heading.component";
+let GdsContextMenu = class extends withMarginProps(
+  withLayoutChildProps(GdsElement)
+) {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _handleItemClick);
+    this.open = false;
+    this.buttonLabel = msg("Open context menu");
+    this.showLabel = false;
+    this.label = "";
+    this.placement = "bottom-start";
+    __privateAdd(this, _renderPopover, () => {
+      return html`<gds-popover
+      id="menu"
+      autofocus
+      .open=${this.open}
+      .triggerRef=${this.elTriggerBtn}
+      .anchorRef=${this.elTriggerBtn}
+      .label=${this.label}
+      .placement=${this.placement}
+      @gds-ui-state=${(e) => this.open = e.detail.open}
+    >
+      <gds-menu
+        aria-label=${this.label ?? this.buttonLabel}
+        @gds-menu-item-click=${__privateMethod(this, _handleItemClick, handleItemClick_fn)}
+      >
+        <slot></slot>
+      </gds-menu>
+    </gds-popover>`;
+    });
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    TransitionalStyles.instance.apply(this, "gds-context-menu");
+    this.addEventListener("keydown", (e) => {
+      if (this.open && e.key == "Tab") {
+        e.preventDefault();
+        this.open = false;
+        this.elTriggerBtn.then((el) => el.focus());
+      }
+    });
+  }
+  render() {
+    return html`<button
+        id="trigger"
+        class="icon border-0 small ${classMap({ highlighted: this.open })}"
+        aria-label=${this.buttonLabel ?? this.label}
+        aria-haspopup="menu"
+        aria-controls="menu"
+        aria-expanded=${this.open}
+        @click=${() => this.open = true}
+      >
+        <slot name="trigger">
+          ${this.showLabel ? this.buttonLabel ?? this.label : nothing}
+          <svg width="24" height="24" viewBox="0 0 24 24">
+            <path
+              d="M14 12C14 13.1042 13.1042 14 12 14C10.8958 14 10 13.1042 10 12C10 10.8958 10.8958 10 12 10C13.1042 10 14 10.8958 14 12ZM19 10C17.8958 10 17 10.8958 17 12C17 13.1042 17.8958 14 19 14C20.1042 14 21 13.1042 21 12C21 10.8958 20.1042 10 19 10ZM5 10C3.89583 10 3 10.8958 3 12C3 13.1042 3.89583 14 5 14C6.10417 14 7 13.1042 7 12C7 10.8958 6.10417 10 5 10Z"
+              fill="#353531"
+            />
+          </svg>
+        </slot>
+      </button>
+      ${when(this.open, __privateGet(this, _renderPopover))}`;
+  }
+};
+_renderPopover = new WeakMap();
+_handleItemClick = new WeakSet();
+handleItemClick_fn = function() {
+  this.open = false;
+};
+GdsContextMenu.styles = [tokens, styles];
+GdsContextMenu.shadowRootOptions = {
+  mode: "open",
+  delegatesFocus: true
+};
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], GdsContextMenu.prototype, "open", 2);
+__decorateClass([
+  property({
+    attribute: "button-label"
+  })
+], GdsContextMenu.prototype, "buttonLabel", 2);
+__decorateClass([
+  property({
+    attribute: "show-label",
+    type: Boolean
+  })
+], GdsContextMenu.prototype, "showLabel", 2);
+__decorateClass([
+  property()
+], GdsContextMenu.prototype, "label", 2);
+__decorateClass([
+  property()
+], GdsContextMenu.prototype, "placement", 2);
+__decorateClass([
+  queryAsync("#trigger")
+], GdsContextMenu.prototype, "elTriggerBtn", 2);
+GdsContextMenu = __decorateClass([
+  gdsCustomElement("gds-context-menu", {
+    dependsOn: [GdsMenuItem, GdsMenu, GdsPopover]
+  }),
+  localized()
+], GdsContextMenu);
+export {
+  GdsContextMenu,
+  GdsMenuHeading,
+  GdsMenuItem
+};