@zanichelli/albe-web-components 3.0.0 → 3.2.0

package/dist/collection/components/z-date-picker/index.js

@@ -1,4 +1,4 @@
-import { Component, Prop, Element, h, Event, State, } from "@stencil/core";
+import { Component, Prop, Element, h, Event, Listen, State, } from "@stencil/core";
 import flatpickr from "flatpickr";
 import { Italian } from "flatpickr/dist/l10n/it.js";
 import monthSelectPlugin from "flatpickr/dist/plugins/monthSelect";
@@ -13,16 +13,55 @@ export class ZDatePicker {
   emitDateSelect(date) {
     this.dateSelect.emit(date);
   }
+  handleKeyDown(ev) {
+    if (ev.key === "Enter" || ev.key === " ") {
+      let isPrevArrowEntered = document.activeElement.classList.contains("flatpickr-prev-month");
+      let isNextArrowEntered = document.activeElement.classList.contains("flatpickr-next-month");
+      let arrowPressed = isPrevArrowEntered || isNextArrowEntered;
+      arrowPressed && ev.key === " " && ev.preventDefault();
+      if (this.mode === ZDatePickerMode.months) {
+        isPrevArrowEntered &&
+          this.flatpickrInstance.changeYear(this.flatpickrInstance.currentYear - 1);
+        isNextArrowEntered &&
+          this.flatpickrInstance.changeYear(this.flatpickrInstance.currentYear + 1);
+        if (arrowPressed) {
+          let calendar = this.element.getElementsByClassName("flatpickr-calendar")[0];
+          let months = calendar.querySelectorAll(".flatpickr-monthSelect-month");
+          months.forEach((element) => {
+            element.setAttribute("aria-label", `${element.innerHTML} ${this.flatpickrInstance.currentYear}`);
+          });
+          //Force check of the current day
+          Array.from(months).forEach((element, index) => {
+            let curMonth = new Date().getMonth();
+            let curYear = new Date().getFullYear();
+            if (index === curMonth) {
+              if (this.flatpickrInstance.currentYear === curYear) {
+                element.setAttribute("class", "flatpickr-monthSelect-month today");
+              }
+              else {
+                element.setAttribute("class", "flatpickr-monthSelect-month");
+              }
+            }
+          });
+        }
+      }
+      else {
+        isPrevArrowEntered && this.flatpickrInstance.changeMonth(-1);
+        isNextArrowEntered && this.flatpickrInstance.changeMonth(1);
+      }
+    }
+  }
   componentWillLoad() {
     let customToggle = this.element.querySelector("[slot=toggle]");
     this.hasChildren = !!customToggle;
     this.hasChildren && customToggle.setAttribute("data-toggle", "data-toggle");
   }
   componentDidLoad() {
-    flatpickr(`.${this.datepickerid}`, {
+    this.flatpickrInstance = flatpickr(`.${this.datepickerid}`, {
       appendTo: this.element.children[0],
       enableTime: this.mode === ZDatePickerMode.dateTime,
       locale: Italian,
+      allowInput: true,
       dateFormat: this.mode === ZDatePickerMode.dateTime ? "d-m-Y - H:i" : "d-m-Y",
       ariaDateFormat: this.mode === ZDatePickerMode.months ? "F Y" : "d F Y",
       minuteIncrement: 1,
@@ -30,6 +69,13 @@ export class ZDatePicker {
       onChange: (_selectedDates, dateStr) => {
         this.emitDateSelect(dateStr);
       },
+      onOpen: () => {
+        this.setAriaOptions();
+        this.setFlatpickrPosition();
+      },
+      onKeyDown: () => {
+        this.setAriaOptions();
+      },
       wrap: this.hasChildren,
       plugins: this.mode === ZDatePickerMode.months && [
         monthSelectPlugin({
@@ -42,6 +88,60 @@ export class ZDatePicker {
       element.innerHTML = element.innerHTML.trim().charAt(0);
     });
   }
+  setAriaOptions() {
+    let calendar = this.element.getElementsByClassName("flatpickr-calendar")[0];
+    let prevMonthArrow = calendar.getElementsByClassName("flatpickr-prev-month")[0];
+    let nextMonthArrow = calendar.getElementsByClassName("flatpickr-next-month")[0];
+    let tabindexElements = calendar.querySelectorAll('[tabindex = "-1"]');
+    tabindexElements.forEach((element) => element.setAttribute("tabindex", "0"));
+    prevMonthArrow.setAttribute("tabindex", "0");
+    nextMonthArrow.setAttribute("tabindex", "0");
+    prevMonthArrow.setAttribute("role", "button");
+    nextMonthArrow.setAttribute("role", "button");
+    calendar
+      .getElementsByClassName("cur-year")[0]
+      .setAttribute("aria-label", "Anno");
+    if (this.mode === ZDatePickerMode.months) {
+      this.setMonthsAriaOptions(calendar, prevMonthArrow, nextMonthArrow);
+    }
+    if (this.mode === ZDatePickerMode.date) {
+      this.setDateAriaOptions(calendar, prevMonthArrow, nextMonthArrow);
+    }
+    if (this.mode === ZDatePickerMode.dateTime) {
+      this.setDateTimeAriaOptions(calendar, prevMonthArrow, nextMonthArrow);
+    }
+  }
+  setMonthsAriaOptions(calendar, prevMonthArrow, nextMonthArrow) {
+    Array.from(calendar.getElementsByClassName("flatpickr-monthSelect-months")).forEach((element) => element.setAttribute("tabindex", "-1"));
+    Array.from(calendar.getElementsByClassName("flatpickr-monthSelect-month")).forEach((element) => element.setAttribute("role", "button"));
+    prevMonthArrow.setAttribute("aria-label", "Anno precedente");
+    nextMonthArrow.setAttribute("aria-label", "Anno successivo");
+  }
+  setDateAriaOptions(calendar, prevMonthArrow, nextMonthArrow) {
+    Array.from(calendar.getElementsByClassName("flatpickr-days")).forEach((element) => element.setAttribute("tabindex", "-1"));
+    Array.from(calendar.getElementsByClassName("flatpickr-day")).forEach((element) => element.setAttribute("role", "button"));
+    calendar
+      .getElementsByClassName("flatpickr-monthDropdown-months")[0]
+      .setAttribute("aria-label", "Mese");
+    prevMonthArrow.setAttribute("aria-label", "Mese precedente");
+    nextMonthArrow.setAttribute("aria-label", "Mese successivo");
+  }
+  setDateTimeAriaOptions(calendar, prevMonthArrow, nextMonthArrow) {
+    Array.from(calendar.getElementsByClassName("flatpickr-days")).forEach((element) => element.setAttribute("tabindex", "-1"));
+    Array.from(calendar.getElementsByClassName("flatpickr-day")).forEach((element) => element.setAttribute("role", "button"));
+    calendar
+      .getElementsByClassName("flatpickr-monthDropdown-months")[0]
+      .setAttribute("aria-label", "Mese");
+    prevMonthArrow.setAttribute("aria-label", "Mese precedente");
+    nextMonthArrow.setAttribute("aria-label", "Mese successivo");
+    Array.from(calendar.getElementsByClassName("time24hr")).forEach((element) => element.setAttribute("tabindex", "-1"));
+    calendar
+      .getElementsByClassName("flatpickr-hour")[0]
+      .setAttribute("aria-label", "Ora");
+    calendar
+      .getElementsByClassName("flatpickr-minute")[0]
+      .setAttribute("aria-label", "Minuti");
+  }
   setFlatpickrPosition() {
     const toggleHeight = this.element.children[0].clientHeight;
     this.element.style.setProperty("--toggle-height", `${toggleHeight}px`);
@@ -66,10 +166,10 @@ export class ZDatePicker {
       h("slot", { name: "toggle" })));
   }
   renderZInput() {
-    return (h("z-input", { class: classNames(this.datepickerid), type: "text", name: "datepicker", icon: "event", hasmessage: false }));
+    return (h("z-input", { class: classNames(this.datepickerid), type: "text", icon: "event", hasmessage: false, tabindex: "0" }));
   }
   render() {
-    return (h("div", { class: classNames("flatpickr-toggle-container", this.hasChildren && this.datepickerid, this.flatpickrPosition, this.mode), onClick: () => this.setFlatpickrPosition() }, this.hasChildren ? this.renderSlottedContent() : this.renderZInput()));
+    return (h("div", { class: classNames("flatpickr-toggle-container", this.hasChildren && this.datepickerid, this.flatpickrPosition, this.mode) }, this.hasChildren ? this.renderSlottedContent() : this.renderZInput()));
   }
   static get is() { return "z-date-picker"; }
   static get originalStyleUrls() { return {
@@ -140,4 +240,11 @@ export class ZDatePicker {
       }
     }]; }
   static get elementRef() { return "element"; }
+  static get listeners() { return [{
+      "name": "keydown",
+      "method": "handleKeyDown",
+      "target": "body",
+      "capture": true,
+      "passive": false
+    }]; }
 }

package/dist/collection/components/z-date-picker/styles.css

@@ -257,11 +257,15 @@ z-date-picker > div > * {
 }
 
 .flatpickr-next-month:hover,
-.flatpickr-prev-month:hover {
+.flatpickr-prev-month:hover,
+.flatpickr-next-month:focus,
+.flatpickr-prev-month:focus {
   border-radius: var(--border-radius);
   background-color: var(--color-primary03) !important;
   border-color: var(--color-primary03) !important;
   color: var(--color-hover-primary) !important;
+  border: none !important;
+  outline: none !important;
 }
 
 .flatpickr-next-month:hover svg,
@@ -296,7 +300,8 @@ z-date-picker > div > * {
   padding-left: var(--space-unit) !important;
 }
 
-.flatpickr-monthDropdown-months:hover {
+.flatpickr-monthDropdown-months:hover,
+.flatpickr-monthDropdown-months:focus {
   outline: 1px solid var(--color-primary01) !important;
 }
 
@@ -311,7 +316,8 @@ z-date-picker > div > * {
   width: calc(var(--space-unit) * 10);
 }
 
-.flatpickr-current-month > .numInputWrapper:hover {
+.flatpickr-current-month > .numInputWrapper:hover,
+.flatpickr-current-month > .numInputWrapper:focus-within {
   outline: 1px solid var(--color-primary01) !important;
 }
 
@@ -368,7 +374,8 @@ z-date-picker > div > * {
 .flatpickr-day:hover,
 .flatpickr-day.prevMonthDay:hover,
 .flatpickr-day.selected:hover,
-.flatpickr-monthSelect-month:hover {
+.flatpickr-monthSelect-month:hover,
+.flatpickr-monthSelect-month:focus {
   background-color: var(--myz-blue-dark) !important;
   border-color: var(--myz-blue-dark) !important;
   color: var(--color-white) !important;
@@ -441,6 +448,9 @@ z-date-picker > div > * {
 
 .flatpickr-minute,
 .flatpickr-hour {
+  font-size: var(--font-size-3) !important;
+  font-weight: var(--font-rg) !important;
+
   outline: 1px solid black !important;
 }
 

package/dist/collection/components/z-pagination/index.js

@@ -0,0 +1,447 @@
+import { Component, Prop, h, Element, Event, Watch, State, Listen, } from "@stencil/core";
+/**
+ * Pagination bar component.
+ */
+export class ZPagination {
+  constructor() {
+    /** Enable navigation arrows. */
+    this.navArrows = true;
+    /** Number of pages to skip. */
+    this.skip = 0;
+    /** Enable buttons to go to the first and last pages. */
+    this.edges = false;
+    /** Current page. */
+    this.currentPage = 1;
+    /**
+     * Internal visible pages variable.
+     * Needed to better handle conflicting props like `visiblePages` and `split`.
+     * This state will change based on props values and validation,
+     * keeping original `visiblePages` value intact.
+     */
+    this._visiblePages = this.visiblePages;
+    /** Used to hides/change some functionalities on smaller screen sizes */
+    this.isMobile = false;
+    /** Value of the go to page input */
+    this.goToPageValue = null;
+  }
+  /**
+   * Set the max width of the pages container.
+   */
+  setPagesContainerWidth() {
+    if (!this._visiblePages || this.split) {
+      this.host.style.setProperty("--z-pagination--pages-container-max-width", "100%");
+      return;
+    }
+    const pagesContainerStyle = window.getComputedStyle(this.host);
+    const pageButtonWidth = pagesContainerStyle.getPropertyValue("--z-pagination--page-button-width");
+    this.host.style.setProperty("--z-pagination--pages-container-max-width", `calc(${pageButtonWidth} * ${this._visiblePages})`);
+  }
+  /**
+   * Set visible pages.
+   * Ensure that the visible pages are always <= the total pages.
+   * If `visiblePages` isn't set, fallback to the total pages.
+   */
+  setVisiblePages() {
+    this._visiblePages = Math.min(this.visiblePages || this.totalPages, this.totalPages);
+  }
+  /**
+   * On page changed.
+   * @emits pageChanged
+   */
+  onPageChanged() {
+    this.pageChanged.emit(this.currentPage);
+    this.scrollToPage();
+  }
+  /**
+   * On split changed.
+   * Empty `edges` value. The split feature wins over the pages chunks and edges.
+   */
+  onSplitChanged() {
+    if (this.split) {
+      this.edges = false;
+    }
+  }
+  /**
+   * Hide stuff on mobile.
+   */
+  onResize() {
+    this.setMobile();
+  }
+  /**
+   * Set functionalities according to screen size.
+   */
+  setMobile() {
+    const mobileMediaQuery = "screen and (max-width: 767px)";
+    this.isMobile = window.matchMedia(mobileMediaQuery).matches;
+  }
+  /**
+   * Get a list of pages chunks, each of `visiblePages` length.
+   * @returns {number[][]}
+   */
+  getPagesChunks() {
+    // array of numbers from 1 to `totalPages`
+    const pages = Array.from({ length: this.totalPages }, (_, i) => i + 1);
+    let chunks = [];
+    const chunksCount = Math.ceil(pages.length / this._visiblePages);
+    for (let index = 0; index < chunksCount; index++) {
+      chunks.push(pages.slice(index * this._visiblePages, (index + 1) * this._visiblePages));
+    }
+    return chunks;
+  }
+  /**
+   * Scroll to the left the chunk of pages containing the current page.
+   */
+  scrollToPage() {
+    const pageBtn = this.host.querySelector(`[data-page="${this.currentPage}"]`);
+    if (!pageBtn) {
+      return;
+    }
+    pageBtn.scrollIntoView({
+      behavior: "smooth",
+      block: "nearest",
+      inline: "center",
+    });
+  }
+  /**
+   * Select a page.
+   * Do validations on the passed value before assigning it to `currentPage`.
+   * @param {number} page Page number to set
+   */
+  selectPage(page) {
+    this.currentPage = Math.min(Math.max(page, 1), this.totalPages);
+  }
+  /**
+   * Render page number button.
+   * @param {number} page Page number to render
+   * @returns {HTMLButtonElement}
+   */
+  renderPage(page) {
+    return (h("button", { class: "page-button", type: "button", "aria-current": this.currentPage === page ? "page" : "false", title: `Vai alla pagina ${page}`, "data-page": page, "data-current": this.currentPage === page, onClick: () => this.selectPage(page) }, page));
+  }
+  /**
+   * Render split button.
+   * @param {number} page Page to select on click.
+   * @returns {HTMLButtonElement}
+   */
+  renderEllipsisButton(page) {
+    return (h("button", { class: "ellipsis-button", type: "button", title: `Vai alla pagina ${page}`, onClick: () => this.selectPage(page) }, "\u2026"));
+  }
+  /**
+   * Render chunked page buttons.
+   * @returns {HTMLDivElement}
+   */
+  renderPages() {
+    const pagesChunks = this.getPagesChunks();
+    if (pagesChunks.length <= 0) {
+      return;
+    }
+    return pagesChunks.map((chunk) => (h("div", { class: "pages-chunk" }, chunk.map((page) => this.renderPage(page)))));
+  }
+  /**
+   * Render page buttons when split feature is enabled.
+   * @returns {HTMLButtonElement[]}
+   */
+  renderSplitPages() {
+    // left and right split pages, current page, first and last page, left and right ellipsis button
+    if (this.totalPages <= this.split * 2 + 5) {
+      // Too few pages: ellipsis will never be rendered, so let's just render all pages and that's it.
+      return Array.from({ length: this.totalPages }, (_, i) => this.renderPage(i + 1));
+    }
+    if (this.currentPage <= this.split * 2 + 2) {
+      // Render first (2 * split + 3) pages, ellipsis, then last page.
+      return [
+        ...Array.from({ length: this.split * 2 + 3 }, (_, i) => this.renderPage(i + 1)),
+        this.renderEllipsisButton(this.split * 2 + 4),
+        this.renderPage(this.totalPages),
+      ];
+    }
+    if (this.currentPage > this.split * 2 + 2 && this.currentPage < this.totalPages - this.split * 2 - 1) {
+      // Render first page, ellipsis, current page surrounded by (split) pages both before and after, another ellipsis, then last page.
+      return [
+        this.renderPage(1),
+        this.renderEllipsisButton(this.currentPage - this.split - 1),
+        ...Array.from({ length: this.split * 2 + 1 }, (_, i) => this.renderPage(this.currentPage - this.split + i)),
+        this.renderEllipsisButton(this.currentPage + this.split + 1),
+        this.renderPage(this.totalPages),
+      ];
+    }
+    // Render first page, ellipsis, then last (2 * split + 3) pages.
+    return [
+      this.renderPage(1),
+      this.renderEllipsisButton(this.totalPages - this.split * 2 - 3),
+      ...Array.from({ length: this.split * 2 + 3 }, (_, i) => this.renderPage(this.totalPages - this.split * 2 - 2 + i)),
+    ];
+  }
+  renderBackButton() {
+    return (h("button", { class: "navigation-button", type: "button", title: "Vai alla pagina precedente", disabled: this.currentPage === 1, onClick: () => this.selectPage(this.currentPage - 1) },
+      h("z-icon", { name: "chevron-left" })));
+  }
+  renderForwardButton() {
+    return (h("button", { class: "navigation-button", type: "button", title: "Vai alla prossima pagina", disabled: this.currentPage === this.totalPages, onClick: () => this.selectPage(this.currentPage + 1) },
+      h("z-icon", { name: "chevron-right" })));
+  }
+  renderMobile() {
+    const pagesChunks = this.getPagesChunks();
+    return [
+      this.label && h("span", { class: "page-label body-1-sb" }, this.label),
+      h("div", { class: "pagination-bar" },
+        this.renderBackButton(),
+        !this.goToPage && (h("div", { class: "pages-container", role: "navigation", tabIndex: -1 }, pagesChunks.length > 0 &&
+          pagesChunks.map((chunk) => (h("div", { class: "pages-chunk" }, chunk.map((page) => this.renderPage(page))))))),
+        this.goToPage && (h("form", { class: "mobile-go-to-page", onSubmit: (ev) => {
+            ev.preventDefault();
+            this.selectPage(this.goToPageValue);
+          } },
+          h("z-input", { class: "go-to-page-input", type: "number", hasmessage: false, onInput: (ev) => { this.goToPageValue = ev.target.value; }, placeholder: this.currentPage.toString(), hasclearicon: false }),
+          h("span", null, `/${this.totalPages}`))),
+        this.renderForwardButton()),
+    ];
+  }
+  componentDidLoad() {
+    this.setVisiblePages();
+  }
+  componentDidRender() {
+    if (this.split) {
+      this.edges = false;
+    }
+    this.setPagesContainerWidth();
+    this.setMobile();
+  }
+  render() {
+    if (this.isMobile) {
+      return this.renderMobile();
+    }
+    return [
+      h("div", { class: "pagination-bar" },
+        this.label && h("span", { class: "page-label body-1-sb" }, this.label),
+        this.edges && (h("button", { class: "pagination-button", type: "button", title: "Vai alla pagina 1", disabled: this.currentPage === 1, onClick: () => this.selectPage(1) }, "Pagina 1")),
+        this.skip < this.totalPages && this.skip > 1 && (h("button", { class: "pagination-button", type: "button", title: `Vai alla pagina ${this.currentPage - this.skip}`, disabled: this.currentPage <= this.skip, onClick: () => this.selectPage(this.currentPage - this.skip) },
+          "-",
+          this.skip)),
+        this.navArrows && this.renderBackButton(),
+        h("div", { class: "pages-container", role: "navigation", tabIndex: -1 }, this.split ?
+          this.renderSplitPages() :
+          this.renderPages()),
+        this.navArrows && this.renderForwardButton(),
+        this.skip < this.totalPages && this.skip > 1 && (h("button", { class: "pagination-button", type: "button", title: `Vai alla pagina ${this.currentPage + this.skip}`, disabled: this.currentPage > this.totalPages - this.skip, onClick: () => this.selectPage(this.currentPage + this.skip) },
+          "+",
+          this.skip)),
+        this.edges && (h("button", { class: "pagination-button", type: "button", title: `Vai alla pagina ${this.totalPages}`, disabled: this.currentPage === this.totalPages, onClick: () => this.selectPage(this.totalPages) },
+          "Pagina ",
+          this.totalPages))),
+      this.goToPage && (h("div", { class: "go-to-page" },
+        h("span", { class: "label body-5-sb" }, "Vai a pagina:"),
+        h("div", { class: "inputs" },
+          h("z-input", { class: "go-to-page-input", type: "number", hasmessage: false, placeholder: "2", hasclearicon: false, onInput: (ev) => { this.goToPageValue = ev.target.value; }, onKeyDown: (ev) => ev.key === "Enter" && this.selectPage(this.goToPageValue) }),
+          h("z-button", { disabled: !this.goToPageValue, title: "Vai alla pagina inserita", onClick: () => this.selectPage(this.goToPageValue) }, "vai")))),
+    ];
+  }
+  static get is() { return "z-pagination"; }
+  static get originalStyleUrls() { return {
+    "$": ["styles.css"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["styles.css"]
+  }; }
+  static get properties() { return {
+    "label": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "Pagination label placed before the bar."
+      },
+      "attribute": "label",
+      "reflect": false
+    },
+    "navArrows": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Enable navigation arrows."
+      },
+      "attribute": "nav-arrows",
+      "reflect": false,
+      "defaultValue": "true"
+    },
+    "totalPages": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": true,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Total number of pages. Required."
+      },
+      "attribute": "total-pages",
+      "reflect": false
+    },
+    "skip": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Number of pages to skip."
+      },
+      "attribute": "skip",
+      "reflect": false,
+      "defaultValue": "0"
+    },
+    "edges": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Enable buttons to go to the first and last pages."
+      },
+      "attribute": "edges",
+      "reflect": false,
+      "defaultValue": "false"
+    },
+    "split": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "Number of pages to show left/right of the current, before showing \"load more\" symbol (\u2026)."
+      },
+      "attribute": "split",
+      "reflect": false
+    },
+    "visiblePages": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "Number of pages to show at a time. If not set, all pages will be shown."
+      },
+      "attribute": "visible-pages",
+      "reflect": false
+    },
+    "currentPage": {
+      "type": "number",
+      "mutable": true,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Current page."
+      },
+      "attribute": "current-page",
+      "reflect": false,
+      "defaultValue": "1"
+    },
+    "goToPage": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Whether to show \"go to page\" feature."
+      },
+      "attribute": "go-to-page",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "_visiblePages": {},
+    "isMobile": {},
+    "goToPageValue": {}
+  }; }
+  static get events() { return [{
+      "method": "pageChanged",
+      "name": "pageChanged",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Event emitted when the current page has changed."
+      },
+      "complexType": {
+        "original": "any",
+        "resolved": "any",
+        "references": {}
+      }
+    }]; }
+  static get elementRef() { return "host"; }
+  static get watchers() { return [{
+      "propName": "_visiblePages",
+      "methodName": "setPagesContainerWidth"
+    }, {
+      "propName": "visiblePages",
+      "methodName": "setVisiblePages"
+    }, {
+      "propName": "currentPage",
+      "methodName": "onPageChanged"
+    }, {
+      "propName": "split",
+      "methodName": "onSplitChanged"
+    }]; }
+  static get listeners() { return [{
+      "name": "resize",
+      "method": "onResize",
+      "target": "window",
+      "capture": false,
+      "passive": true
+    }]; }
+}