@cruglobal/cornerstone-components 0.1.2 → 0.1.3

package/dist/unbundled/chunks/chunk.NGQTD2EE.js

@@ -0,0 +1,151 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/components/card/card.styles.ts
+import { css } from "lit";
+var card_styles_default = css`
+  :host {
+    --spacing: var(--cs-space-l);
+
+    /* Internal calculated properties */
+    --inner-border-radius: calc(var(--cs-panel-border-radius) - var(--cs-panel-border-width));
+
+    display: flex;
+    flex-direction: column;
+    background-color: var(--cs-color-surface-default);
+    border-color: var(--cs-color-surface-border);
+    border-radius: var(--cs-panel-border-radius);
+    border-style: var(--cs-panel-border-style);
+    box-shadow: var(--cs-shadow-s);
+    border-width: var(--cs-panel-border-width);
+    color: var(--cs-color-text-normal);
+  }
+
+  /* Appearance modifiers */
+  :host([appearance='plain']) {
+    background-color: transparent;
+    border-color: transparent;
+    box-shadow: none;
+  }
+
+  :host([appearance='outlined']) {
+    background-color: var(--cs-color-surface-default);
+    border-color: var(--cs-color-surface-border);
+  }
+
+  :host([appearance='filled']) {
+    background-color: var(--cs-color-neutral-fill-quiet);
+    border-color: transparent;
+  }
+
+  :host([appearance='filled-outlined']) {
+    background-color: var(--cs-color-neutral-fill-quiet);
+    border-color: var(--cs-color-surface-border);
+  }
+
+  :host([appearance='accent']) {
+    color: var(--cs-color-neutral-on-loud);
+    background-color: var(--cs-color-neutral-fill-loud);
+    border-color: transparent;
+  }
+
+  /* Take care of top and bottom radii */
+  .media,
+  :host(:not([has-media])) .header,
+  :host(:not([has-media], [has-header])) .body {
+    border-start-start-radius: var(--inner-border-radius);
+    border-start-end-radius: var(--inner-border-radius);
+  }
+
+  :host(:not([has-footer])) .body,
+  .footer {
+    border-end-start-radius: var(--inner-border-radius);
+    border-end-end-radius: var(--inner-border-radius);
+  }
+
+  .media {
+    display: flex;
+    overflow: hidden;
+
+    &::slotted(*) {
+      display: block;
+      width: 100%;
+      border-radius: 0 !important;
+    }
+  }
+
+  /* Round all corners for plain appearance */
+  :host([appearance='plain']) .media {
+    border-radius: var(--inner-border-radius);
+
+    &::slotted(*) {
+      border-radius: inherit !important;
+    }
+  }
+
+  .header {
+    display: block;
+    border-block-end-style: inherit;
+    border-block-end-color: var(--cs-color-surface-border);
+    border-block-end-width: var(--cs-panel-border-width);
+    padding: calc(var(--spacing) / 2) var(--spacing);
+  }
+
+  .body {
+    display: block;
+    padding: var(--spacing);
+  }
+
+  .footer {
+    display: block;
+    border-block-start-style: inherit;
+    border-block-start-color: var(--cs-color-surface-border);
+    border-block-start-width: var(--cs-panel-border-width);
+    padding: var(--spacing);
+  }
+
+  /* Push slots to sides when the action slots renders */
+  .has-actions {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+
+  :host(:not([has-header])) .header,
+  :host(:not([has-footer])) .footer,
+  :host(:not([has-media])) .media {
+    display: none;
+  }
+
+  /* Orientation Styles */
+  :host([orientation='horizontal']) {
+    flex-direction: row;
+
+    .media {
+      border-start-start-radius: var(--inner-border-radius);
+      border-end-start-radius: var(--inner-border-radius);
+      border-start-end-radius: 0;
+
+      &::slotted(*) {
+        block-size: 100%;
+        inline-size: 100%;
+        object-fit: cover;
+      }
+    }
+  }
+
+  :host([orientation='horizontal']) .body slot::slotted(*) {
+    display: block;
+    height: 100%;
+    margin: 0;
+  }
+
+  :host([orientation='horizontal']) slot[name='actions']::slotted(*) {
+    display: flex;
+    align-items: center;
+    padding: var(--spacing);
+  }
+`;
+
+export {
+  card_styles_default
+};

package/dist/unbundled/chunks/chunk.NLYR34WI.js

@@ -0,0 +1,13 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/events/slide-change.ts
+var CsSlideChangeEvent = class extends Event {
+  constructor(detail) {
+    super("cs-slide-change", { bubbles: true, cancelable: false, composed: true });
+    this.detail = detail;
+  }
+};
+
+export {
+  CsSlideChangeEvent
+};

package/dist/unbundled/chunks/chunk.NNPXF2AL.js

@@ -0,0 +1,180 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  registerTranslation
+} from "./chunk.FZ4QCNJ4.js";
+
+// src/translations/de.ts
+var translation = {
+  $code: "de",
+  $name: "Deutsch",
+  $dir: "ltr",
+  am: "AM",
+  autosizeColumn: "Spaltenbreite anpassen",
+  captions: "Untertitel",
+  carousel: "Karussell",
+  chooseDate: "Datum ausw\xE4hlen",
+  chooseDecade: "Jahrzehnt ausw\xE4hlen",
+  chooseMonth: "Monat ausw\xE4hlen",
+  chooseTime: "Uhrzeit ausw\xE4hlen",
+  chooseYear: "Jahr ausw\xE4hlen",
+  clearEntry: "Eingabe l\xF6schen",
+  clearFilter: "Filter aufheben",
+  clearSort: "Sortierung aufheben",
+  close: "Schlie\xDFen",
+  closeCalendar: "Kalender schlie\xDFen",
+  closeTimeInput: "Uhrzeitauswahl schlie\xDFen",
+  collapseRow: "Zeile einklappen",
+  columnMenu: "Spaltenoptionen",
+  columnMovedToPosition: (label, position, total) => `${label} an Position ${position} von ${total} verschoben`,
+  columns: "Spalten",
+  compactPageXOfY: (page, total) => `${page} von ${total}`,
+  copied: "Kopiert",
+  copy: "Kopieren",
+  createOption: (value) => `\u201E${value}" erstellen`,
+  currentlyPlaying: "wird gerade abgespielt",
+  currentValue: "Aktueller Wert",
+  date: "Datum",
+  datePickerKeyboardHelp: "Verwenden Sie die Pfeiltasten, um Werte zu \xE4ndern; dr\xFCcken Sie Alt+Pfeil nach unten, um den Kalender zu \xF6ffnen.",
+  day: "Tag",
+  dayPeriod: "AM/PM",
+  decrement: "Verringern",
+  deselectAllRows: "Alle Zeilen abw\xE4hlen",
+  dropFileHere: "Datei hier ablegen oder zum Durchsuchen klicken",
+  dropFilesHere: "Dateien hier ablegen oder zum Durchsuchen klicken",
+  empty: "Leer",
+  endDate: "Enddatum",
+  enterFullscreen: "Vollbildmodus aktivieren",
+  error: "Fehler",
+  exitFullscreen: "Vollbildmodus beenden",
+  expandRow: "Zeile ausklappen",
+  filterByColumn: (label) => `Nach ${label} filtern`,
+  filterFrom: "Von",
+  filterMax: "Max",
+  filterMin: "Min",
+  filterTo: "Bis",
+  firstPage: "Erste Seite",
+  goToSlide: (slide, count) => `Zu Folie ${slide} von ${count} gehen`,
+  hideColumn: "Spalte ausblenden",
+  hidePassword: "Passwort verbergen",
+  hour: "Stunde",
+  incompleteDate: "Geben Sie ein g\xFCltiges Datum ein.",
+  increment: "Erh\xF6hen",
+  jumpBackwardX: (count) => `${count} Seiten zur\xFCckspringen`,
+  jumpForwardX: (count) => `${count} Seiten vorw\xE4rtsspringen`,
+  lastPage: "Letzte Seite",
+  loading: "Wird geladen",
+  minute: "Minute",
+  month: "Monat",
+  moreOptions: "Weitere Optionen",
+  mute: "Stummschalten",
+  nextDecade: "N\xE4chstes Jahrzehnt",
+  nextMonth: "N\xE4chster Monat",
+  nextPage: "N\xE4chste Seite",
+  nextSlide: "N\xE4chste Folie",
+  nextVideo: "N\xE4chstes Video",
+  nextYear: "N\xE4chstes Jahr",
+  noData: "Keine Daten",
+  noResults: "Keine passenden Ergebnisse",
+  now: "Jetzt",
+  numCharacters: (num) => {
+    if (num === 1) {
+      return "1 Zeichen";
+    }
+    return `${num} Zeichen`;
+  },
+  numCharactersRemaining: (num) => {
+    if (num === 1) {
+      return "1 Zeichen verbleibend";
+    }
+    return `${num} Zeichen verbleibend`;
+  },
+  numOptionsSelected: (num) => {
+    if (num === 0) {
+      return "Keine Optionen ausgew\xE4hlt";
+    }
+    if (num === 1) {
+      return "1 Option ausgew\xE4hlt";
+    }
+    return `${num} Optionen ausgew\xE4hlt`;
+  },
+  numRowsCopied: (num) => num === 1 ? "1 Zeile kopiert" : `${num} Zeilen kopiert`,
+  numRowsSelected: (num) => num === 1 ? "1 Zeile ausgew\xE4hlt" : `${num} Zeilen ausgew\xE4hlt`,
+  pageXOfY: (page, total) => `Seite ${page} von ${total}`,
+  pagination: "Seitennavigation",
+  pause: "Pausieren",
+  pauseAnimation: "Animation pausieren",
+  pictureInPicture: "Bild im Bild",
+  pinLeft: "Links anheften",
+  pinRight: "Rechts anheften",
+  play: "Abspielen",
+  playAnimation: "Animation abspielen",
+  playbackSpeed: "Abspielgeschwindigkeit",
+  playlist: "Wiedergabeliste",
+  pm: "PM",
+  previousDecade: "Vorheriges Jahrzehnt",
+  previousMonth: "Vorheriger Monat",
+  previousPage: "Vorherige Seite",
+  previousSlide: "Vorherige Folie",
+  previousVideo: "Vorheriges Video",
+  previousYear: "Vorheriges Jahr",
+  progress: "Fortschritt",
+  rangeTooLong: (max) => {
+    if (max === 1) {
+      return "W\xE4hlen Sie einen Zeitraum von h\xF6chstens 1 Tag";
+    }
+    return `W\xE4hlen Sie einen Zeitraum von h\xF6chstens ${max} Tagen`;
+  },
+  rangeTooShort: (min) => {
+    if (min === 1) {
+      return "W\xE4hlen Sie einen Zeitraum von mindestens 1 Tag";
+    }
+    return `W\xE4hlen Sie einen Zeitraum von mindestens ${min} Tagen`;
+  },
+  readonly: "Schreibgesch\xFCtzt",
+  remove: "Entfernen",
+  resetColumns: "Spalten zur\xFCcksetzen",
+  resize: "Gr\xF6\xDFe \xE4ndern",
+  resizeColumn: "Spaltenbreite \xE4ndern",
+  rowsPerPage: "Zeilen pro Seite",
+  scrollableRegion: "Scrollbarer Bereich",
+  scrollToEnd: "Zum Ende scrollen",
+  scrollToStart: "Zum Anfang scrollen",
+  search: "Suchen",
+  second: "Sekunde",
+  seek: "Suchen",
+  seekProgress: (current, duration) => `${current} von ${duration}`,
+  selectAColorFromTheScreen: "Farbe vom Bildschirm ausw\xE4hlen",
+  selectAllRows: "Alle Zeilen ausw\xE4hlen",
+  selected: "Ausgew\xE4hlt",
+  selectedDateLabel: (date) => `Ausgew\xE4hlt: ${date}`,
+  selectedRangeLabel: (range) => `Ausgew\xE4hlter Zeitraum: ${range}`,
+  selectGroup: "Gruppe ausw\xE4hlen",
+  selectionCleared: "Auswahl aufgehoben",
+  selectRow: "Zeile ausw\xE4hlen",
+  showingNofMRows: (shown, total) => `${shown} von ${total} Zeilen werden angezeigt`,
+  showingXtoYofZ: (start, end, total) => `${start}\u2013${end} von ${total}`,
+  showPassword: "Passwort anzeigen",
+  slideNum: (slide) => `Folie ${slide}`,
+  sortAscending: "Aufsteigend sortieren",
+  sortColumn: "Spalte sortieren",
+  sortDescending: "Absteigend sortieren",
+  startDate: "Startdatum",
+  time: "Uhrzeit",
+  timeInputKeyboardHelp: "Verwenden Sie die Pfeiltasten, um Werte zu \xE4ndern; dr\xFCcken Sie Alt+Pfeil nach unten, um die Uhrzeitauswahl zu \xF6ffnen.",
+  today: "Heute",
+  toggleColorFormat: "Farbformat wechseln",
+  unmute: "Stummschaltung aufheben",
+  unpin: "L\xF6sen",
+  unpinColumn: "Spalte l\xF6sen",
+  videoPlayer: "Videoplayer",
+  volume: "Lautst\xE4rke",
+  year: "Jahr",
+  zoomIn: "Hineinzoomen",
+  zoomOut: "Herauszoomen"
+};
+registerTranslation(translation);
+var de_default = translation;
+
+export {
+  de_default
+};

package/dist/unbundled/chunks/chunk.NPRMFSDD.js

@@ -0,0 +1,13 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+
+// src/events/include-error.ts
+var CsIncludeErrorEvent = class extends Event {
+  constructor(detail) {
+    super("cs-include-error", { bubbles: true, cancelable: false, composed: true });
+    this.detail = detail;
+  }
+};
+
+export {
+  CsIncludeErrorEvent
+};

package/dist/unbundled/chunks/chunk.NVJTVMZ4.js

@@ -0,0 +1,340 @@
+/*! Cornerstone Components 0.1.3 - MIT licensed. See LICENSE.md and NOTICE. */
+import {
+  CsSelectionChangeEvent
+} from "./chunk.IT67IFGK.js";
+import {
+  CsTreeItem
+} from "./chunk.3EEECQKJ.js";
+import {
+  tree_styles_default
+} from "./chunk.CNMLKDSL.js";
+import {
+  clamp
+} from "./chunk.OQW3LNFH.js";
+import {
+  watch
+} from "./chunk.MBVC472U.js";
+import {
+  CornerstoneElement,
+  customElement
+} from "./chunk.LGF4LDQG.js";
+import {
+  LocalizeController
+} from "./chunk.FZ4QCNJ4.js";
+import {
+  __decorateClass
+} from "./chunk.6UN6XRW4.js";
+
+// src/components/tree/tree.ts
+import { html } from "lit";
+import { property, query } from "lit/decorators.js";
+function syncCheckboxes(changedTreeItem, initialSync = false) {
+  function syncParentItem(treeItem) {
+    const children = treeItem.getChildrenItems({ includeDisabled: false });
+    if (children.length) {
+      const allChecked = children.every((item) => item.selected);
+      const allUnchecked = children.every((item) => !item.selected && !item.indeterminate);
+      treeItem.selected = allChecked;
+      treeItem.indeterminate = !allChecked && !allUnchecked;
+    }
+  }
+  function syncAncestors(treeItem) {
+    const parentItem = treeItem.parentElement;
+    if (CsTreeItem.isTreeItem(parentItem)) {
+      syncParentItem(parentItem);
+      syncAncestors(parentItem);
+    }
+  }
+  function syncDescendants(treeItem) {
+    for (const childItem of treeItem.getChildrenItems()) {
+      childItem.selected = initialSync ? treeItem.selected || childItem.selected : !childItem.disabled && treeItem.selected;
+      syncDescendants(childItem);
+    }
+    if (initialSync) {
+      syncParentItem(treeItem);
+    }
+  }
+  syncDescendants(changedTreeItem);
+  syncAncestors(changedTreeItem);
+}
+var CsTree = class extends CornerstoneElement {
+  constructor() {
+    super();
+    this.selection = "single";
+    this.clickTarget = null;
+    this.localize = new LocalizeController(this);
+    this.tabIndex = 0;
+    this.role = "tree";
+    // Initializes new items by setting the `selectable` property and the expanded/collapsed icons if any
+    this.initTreeItem = (item) => {
+      item.updateComplete.then(() => {
+        item.selectable = this.selection === "multiple" || this.selection === "leaf-multiple" && item.isLeaf;
+        ["expand", "collapse"].filter((status) => !!this.querySelector(`[slot="${status}-icon"]`)).forEach((status) => {
+          const existingIcon = item.querySelector(`[slot="${status}-icon"]`);
+          const expandButtonIcon = this.getExpandButtonIcon(status);
+          if (!expandButtonIcon) {
+            return;
+          }
+          if (existingIcon === null) {
+            item.append(expandButtonIcon);
+          } else if (existingIcon.hasAttribute("data-default")) {
+            existingIcon.replaceWith(expandButtonIcon);
+          } else {
+          }
+        });
+      });
+    };
+    this.handleTreeChanged = (mutations) => {
+      for (const mutation of mutations) {
+        const addedNodes = [...mutation.addedNodes].filter(CsTreeItem.isTreeItem);
+        const removedNodes = [...mutation.removedNodes].filter(CsTreeItem.isTreeItem);
+        addedNodes.forEach(this.initTreeItem);
+        if (this.lastFocusedItem && removedNodes.includes(this.lastFocusedItem)) {
+          this.lastFocusedItem = null;
+        }
+      }
+    };
+    this.handleFocusOut = (event) => {
+      const relatedTarget = event.relatedTarget;
+      if (!relatedTarget || !this.contains(relatedTarget)) {
+        this.tabIndex = 0;
+      }
+    };
+    this.handleFocusIn = (event) => {
+      const target = event.target;
+      if (event.target === this) {
+        this.focusItem(this.lastFocusedItem || this.getAllTreeItems()[0]);
+      }
+      if (CsTreeItem.isTreeItem(target) && !target.disabled) {
+        if (this.lastFocusedItem) {
+          this.lastFocusedItem.tabIndex = -1;
+        }
+        this.lastFocusedItem = target;
+        this.tabIndex = -1;
+        target.tabIndex = 0;
+      }
+    };
+    if ("addEventListener" in this) {
+      this.addEventListener("focusin", this.handleFocusIn);
+      this.addEventListener("focusout", this.handleFocusOut);
+      this.addEventListener("cs-lazy-change", this.handleSlotChange);
+    }
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    if (typeof MutationObserver !== "undefined") {
+      await this.updateComplete;
+      this.mutationObserver = new MutationObserver(this.handleTreeChanged);
+      this.mutationObserver.observe(this, { childList: true, subtree: true });
+    }
+    this.setAttribute("tabindex", "0");
+    this.setAttribute("role", "tree");
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.mutationObserver?.disconnect();
+  }
+  // Generates a clone of the expand icon element to use for each tree item
+  getExpandButtonIcon(status) {
+    const slot = status === "expand" ? this.expandedIconSlot : this.collapsedIconSlot;
+    const icon = slot.assignedElements({ flatten: true })[0];
+    if (icon) {
+      const clone = icon.cloneNode(true);
+      [clone, ...clone.querySelectorAll("[id]")].forEach((el) => el.removeAttribute("id"));
+      clone.setAttribute("data-default", "");
+      clone.slot = `${status}-icon`;
+      return clone;
+    }
+    return null;
+  }
+  selectItem(selectedItem) {
+    const previousSelection = [...this.selectedItems];
+    if (this.selection === "multiple") {
+      selectedItem.selected = !selectedItem.selected;
+      if (selectedItem.lazy) {
+        selectedItem.expanded = true;
+      }
+      syncCheckboxes(selectedItem);
+    } else if (this.selection === "leaf-multiple") {
+      if (selectedItem.isLeaf) {
+        selectedItem.selected = !selectedItem.selected;
+      } else {
+        selectedItem.expanded = !selectedItem.expanded;
+      }
+    } else if (this.selection === "single" || selectedItem.isLeaf) {
+      const items = this.getAllTreeItems();
+      for (const item of items) {
+        item.selected = item === selectedItem;
+      }
+    } else if (this.selection === "leaf") {
+      selectedItem.expanded = !selectedItem.expanded;
+    }
+    const nextSelection = this.selectedItems;
+    if (previousSelection.length !== nextSelection.length || nextSelection.some((item) => !previousSelection.includes(item))) {
+      Promise.all(nextSelection.map((el) => el.updateComplete)).then(() => {
+        this.dispatchEvent(new CsSelectionChangeEvent({ selection: nextSelection }));
+      });
+    }
+  }
+  getAllTreeItems() {
+    return [...this.querySelectorAll("cs-tree-item")];
+  }
+  focusItem(item) {
+    item?.focus();
+  }
+  handleKeyDown(event) {
+    if (!["ArrowDown", "ArrowUp", "ArrowRight", "ArrowLeft", "Home", "End", "Enter", " "].includes(event.key)) {
+      return;
+    }
+    if (event.composedPath().some((el) => ["input", "textarea"].includes(el?.tagName?.toLowerCase()))) {
+      return;
+    }
+    const items = this.getFocusableItems();
+    const isLtr = this.matches(":dir(ltr)");
+    const isRtl = this.localize.dir() === "rtl";
+    if (items.length > 0) {
+      const activeItemIndex = items.findIndex((item) => item.matches(":focus"));
+      const activeItem = items[activeItemIndex];
+      if (!activeItem && (event.key === "Enter" || event.key === " ")) {
+        return;
+      }
+      event.preventDefault();
+      const focusItemAt = (index) => {
+        const item = items[clamp(index, 0, items.length - 1)];
+        this.focusItem(item);
+      };
+      const toggleExpand = (expanded) => {
+        activeItem.expanded = expanded;
+      };
+      if (event.key === "ArrowDown") {
+        focusItemAt(activeItemIndex + 1);
+      } else if (event.key === "ArrowUp") {
+        focusItemAt(activeItemIndex - 1);
+      } else if (isLtr && event.key === "ArrowRight" || isRtl && event.key === "ArrowLeft") {
+        if (!activeItem || activeItem.disabled || activeItem.expanded || activeItem.isLeaf && !activeItem.lazy) {
+          focusItemAt(activeItemIndex + 1);
+        } else {
+          toggleExpand(true);
+        }
+      } else if (isLtr && event.key === "ArrowLeft" || isRtl && event.key === "ArrowRight") {
+        if (!activeItem || activeItem.disabled || activeItem.isLeaf || !activeItem.expanded) {
+          focusItemAt(activeItemIndex - 1);
+        } else {
+          toggleExpand(false);
+        }
+      } else if (event.key === "Home") {
+        focusItemAt(0);
+      } else if (event.key === "End") {
+        focusItemAt(items.length - 1);
+      } else if (event.key === "Enter" || event.key === " ") {
+        if (activeItem && !activeItem.disabled) {
+          this.selectItem(activeItem);
+        }
+      }
+    }
+  }
+  handleClick(event) {
+    const target = event.target;
+    const treeItem = target.closest("cs-tree-item");
+    const isExpandButton = event.composedPath().some((el) => el?.classList?.contains("expand-button"));
+    if (!treeItem || treeItem.disabled || target !== this.clickTarget) {
+      return;
+    }
+    if (isExpandButton) {
+      treeItem.expanded = !treeItem.expanded;
+    } else {
+      this.selectItem(treeItem);
+    }
+  }
+  handleMouseDown(event) {
+    this.clickTarget = event.target;
+  }
+  handleSlotChange() {
+    const items = this.getAllTreeItems();
+    items.forEach(this.initTreeItem);
+  }
+  async handleSelectionChange() {
+    const isSelectionMultiple = this.selection === "multiple";
+    const isSelectionLeafMultiple = this.selection === "leaf-multiple";
+    const items = this.getAllTreeItems();
+    this.setAttribute("aria-multiselectable", isSelectionMultiple || isSelectionLeafMultiple ? "true" : "false");
+    for (const item of items) {
+      item.updateComplete.then(() => {
+        item.selectable = isSelectionMultiple || isSelectionLeafMultiple && item.isLeaf;
+      });
+    }
+    if (isSelectionMultiple) {
+      await this.updateComplete;
+      [...this.querySelectorAll(":scope > cs-tree-item")].forEach((treeItem) => {
+        treeItem.updateComplete.then(() => {
+          syncCheckboxes(treeItem, true);
+        });
+      });
+    }
+  }
+  /** @internal Returns the list of tree items that are selected in the tree. */
+  get selectedItems() {
+    const items = this.getAllTreeItems();
+    const isSelected = (item) => item.selected;
+    return items.filter(isSelected);
+  }
+  /** @internal Gets focusable tree items in the tree. */
+  getFocusableItems() {
+    const items = this.getAllTreeItems();
+    const collapsedItems = /* @__PURE__ */ new Set();
+    return items.filter((item) => {
+      if (item.disabled) {
+        return false;
+      }
+      const parent = item.parentElement?.closest("[role=treeitem]");
+      if (parent && (!parent.expanded || parent.loading || collapsedItems.has(parent))) {
+        collapsedItems.add(item);
+      }
+      return !collapsedItems.has(item);
+    });
+  }
+  render() {
+    return html`
+      <div
+        part="tree"
+        class="tree"
+        @click=${this.handleClick}
+        @keydown=${this.handleKeyDown}
+        @mousedown=${this.handleMouseDown}
+      >
+        <slot @slotchange=${this.handleSlotChange}></slot>
+        <span hidden aria-hidden="true"><slot name="expand-icon"></slot></span>
+        <span hidden aria-hidden="true"><slot name="collapse-icon"></slot></span>
+      </div>
+    `;
+  }
+};
+CsTree.css = tree_styles_default;
+__decorateClass([
+  query("slot:not([name])")
+], CsTree.prototype, "defaultSlot", 2);
+__decorateClass([
+  query("slot[name=expand-icon]")
+], CsTree.prototype, "expandedIconSlot", 2);
+__decorateClass([
+  query("slot[name=collapse-icon]")
+], CsTree.prototype, "collapsedIconSlot", 2);
+__decorateClass([
+  property()
+], CsTree.prototype, "selection", 2);
+__decorateClass([
+  property({ attribute: "tabindex", reflect: true, type: Number })
+], CsTree.prototype, "tabIndex", 2);
+__decorateClass([
+  property({ reflect: true })
+], CsTree.prototype, "role", 2);
+__decorateClass([
+  watch("selection")
+], CsTree.prototype, "handleSelectionChange", 1);
+CsTree = __decorateClass([
+  customElement("cs-tree")
+], CsTree);
+
+export {
+  CsTree
+};