@haiilo/catalyst 5.3.0 → 5.4.0

package/dist/collection/components/cat-datepicker/cat-datepicker.js

@@ -0,0 +1,873 @@
+import { Host, h } from '@stencil/core';
+import log from 'loglevel';
+import dayjs from './dayjs.config';
+import Datepicker, { getDatepickerOptions } from './vanillajs-datepicker.config';
+/**
+ * Inputs are used to allow users to provide text input when the expected input
+ * is short. As well as plain text, Input supports various types of text,
+ * including passwords and numbers.
+ *
+ * @slot hint - Optional hint element to be displayed with the input.
+ * @slot label - The slotted label. If both the label property and the label slot are present, only the label slot will be displayed.
+ * @part label - The label content.
+ */
+export class CatDatepicker {
+  constructor() {
+    this.hasSlottedLabel = false;
+    this.hasSlottedHint = false;
+    this.requiredMarker = 'optional';
+    this.horizontal = false;
+    this.autoComplete = undefined;
+    this.clearable = false;
+    this.disabled = false;
+    this.hint = undefined;
+    this.icon = undefined;
+    this.iconLeft = false;
+    this.identifier = undefined;
+    this.label = '';
+    this.labelHidden = false;
+    this.max = undefined;
+    this.min = undefined;
+    this.name = undefined;
+    this.placeholder = undefined;
+    this.textPrefix = undefined;
+    this.textSuffix = undefined;
+    this.readonly = false;
+    this.required = false;
+    this.format = 'mm/dd/yyyy';
+    this.weekNumbers = true;
+    this.type = 'date';
+    this.datesDisabled = undefined;
+    this.value = undefined;
+    this.errors = undefined;
+    this.errorUpdate = 0;
+    this.nativeAttributes = undefined;
+  }
+  /**
+   * Programmatically move focus to the input. Use this method instead of
+   * `input.focus()`.
+   *
+   * @param options An optional object providing options to control aspects of
+   * the focusing process.
+   */
+  async doFocus(options) {
+    this.input.focus(options);
+  }
+  /**
+   * Programmatically remove focus from the input. Use this method instead of
+   * `input.blur()`.
+   */
+  async doBlur() {
+    this.input.blur();
+  }
+  /**
+   * Programmatically simulate a click on the input.
+   */
+  async doClick() {
+    this.input.click();
+  }
+  /**
+   * Clear the input.
+   */
+  async clear() {
+    this.value = '';
+  }
+  componentWillRender() {
+    this.hasSlottedLabel = !!this.hostElement.querySelector('[slot="label"]');
+    this.hasSlottedHint = !!this.hostElement.querySelector('[slot="hint"]');
+  }
+  render() {
+    return (h(Host, null, h("cat-input", { ref: el => (this.catInput = el), requiredMarker: this.requiredMarker, horizontal: this.horizontal, autoComplete: this.autoComplete, clearable: this.clearable, disabled: this.disabled, hint: this.hint, icon: this.icon, iconRight: !this.iconLeft, identifier: this.identifier, label: this.label, labelHidden: this.labelHidden, name: this.name, placeholder: this.placeholder, textPrefix: this.textPrefix, textSuffix: this.textSuffix, readonly: this.readonly, required: this.required, value: this.value, errors: this.errors, errorUpdate: this.errorUpdate, nativeAttributes: this.nativeAttributes, onCatChange: event => this.onCatChange(event), onCatFocus: event => this.onCatFocus(event.detail), onCatBlur: event => this.onCatBlur(event.detail) }, this.hasSlottedLabel && (h("span", { slot: "label" }, h("slot", { name: "label" }))), this.hasSlottedHint && (h("span", { slot: "hint" }, h("slot", { name: "hint" }))))));
+  }
+  componentDidLoad() {
+    var _a;
+    if (this.hostElement) {
+      const inputWrapper = (_a = this.catInput.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.input-wrapper');
+      const inputElement = inputWrapper === null || inputWrapper === void 0 ? void 0 : inputWrapper.querySelector('input');
+      if (inputElement) {
+        this.input = inputElement;
+      }
+      else {
+        log.error('[CatInput] Missing input element', this);
+        return;
+      }
+      this.datepicker = new Datepicker(inputElement, Object.assign(Object.assign({}, getDatepickerOptions(this.type, this.value)), { container: inputWrapper, maxDate: this.max, minDate: this.min, datesDisabled: this.datesDisabled, prevArrow: '←', nextArrow: '→', weekNumbers: this.weekNumbers ? 1 : 0, format: {
+          toValue: (dateStr) => this.type === 'week' ? this.fromISOWeek(dateStr) : Datepicker.parseDate(dateStr, this.dateFormat),
+          toDisplay: (date) => this.type === 'week' ? this.toISOWeek(date).toString() : Datepicker.formatDate(date, this.dateFormat)
+        }, beforeShowDay: (date) => (this.shouldHighlightAsToday(date) ? 'today' : null), beforeShowMonth: (date) => (this.shouldHighlightAsToday(date) ? 'today' : null), beforeShowYear: (date) => (this.shouldHighlightAsToday(date) ? 'today' : null) }));
+      if (this.type === 'week') {
+        this.datepicker.pickerElement.classList.add('weekly');
+      }
+      this.input.addEventListener('show', this.handleWeekDays.bind(this));
+      this.input.addEventListener('changeDate', this.handleDateChange.bind(this));
+      this.input.addEventListener('changeMonth', this.handleWeekDays.bind(this));
+      this.input.addEventListener('changeView', this.handleWeekDays.bind(this));
+      this.input.addEventListener('keydown', this.focusAllWeekDays.bind(this));
+    }
+  }
+  disconnectedCallback() {
+    this.input.removeEventListener('show', this.handleWeekDays.bind(this));
+    this.input.removeEventListener('changeDate', this.handleDateChange.bind(this));
+    this.input.removeEventListener('changeMonth', this.handleWeekDays.bind(this));
+    this.input.removeEventListener('changeView', this.handleWeekDays.bind(this));
+    this.input.removeEventListener('keydown', this.focusAllWeekDays.bind(this));
+  }
+  handleDateChange(event) {
+    this.selectAllWeekDays(event.detail.date);
+    this.value = this.input.value;
+    this.catChange.emit();
+  }
+  handleWeekDays(event) {
+    this.selectAllWeekDays(event);
+    this.focusAllWeekDays();
+  }
+  selectAllWeekDays(event) {
+    var _a, _b;
+    const date = event instanceof Date ? event : (_a = event.detail) === null || _a === void 0 ? void 0 : _a.date;
+    if (this.type !== 'week') {
+      return;
+    }
+    if ((_b = this.input) === null || _b === void 0 ? void 0 : _b.value) {
+      const firstDayOfWeek = dayjs(date).startOf('isoWeek');
+      if (!firstDayOfWeek.isSame(dayjs(date).startOf('day'))) {
+        this.datepicker.setDate(firstDayOfWeek.toDate());
+      }
+      else {
+        this.addClassToAllWeekDays('selected');
+      }
+    }
+  }
+  focusAllWeekDays() {
+    const date = dayjs(this.datepicker.picker.viewDate);
+    if (this.type !== 'week' || !date) {
+      return;
+    }
+    const firstDayOfWeek = dayjs(date).startOf('isoWeek');
+    if (!firstDayOfWeek.isSame(dayjs(date).startOf('day'))) {
+      this.datepicker.setFocusedDate(firstDayOfWeek.toDate());
+    }
+    this.addClassToAllWeekDays('focused');
+  }
+  addClassToAllWeekDays(className) {
+    let weekdaysCount = 7;
+    const pickerElement = this.datepicker.pickerElement;
+    let selected = pickerElement.querySelector(`.datepicker-cell:not(.month):not(.year).${className}`);
+    while (weekdaysCount > 1) {
+      if (selected) {
+        selected = selected.nextElementSibling;
+        selected === null || selected === void 0 ? void 0 : selected.classList.add(className);
+        weekdaysCount--;
+      }
+      else {
+        break;
+      }
+    }
+  }
+  onCatChange(event) {
+    this.value = this.input.value;
+    this.catChange.emit(event);
+  }
+  onCatFocus(event) {
+    this.catFocus.emit(event);
+  }
+  onCatBlur(event) {
+    this.catBlur.emit(event);
+  }
+  shouldHighlightAsToday(date) {
+    const now = new Date();
+    const isSameYear = now.getFullYear() === date.getFullYear();
+    const isSameMonth = now.getMonth() === date.getMonth();
+    const isSameDay = now.getDate() === date.getDate();
+    switch (this.type) {
+      case 'date':
+        return isSameYear && isSameMonth && isSameDay;
+      case 'week':
+        return isSameYear && this.toISOWeek(now) === this.toISOWeek(date);
+      case 'month':
+        return isSameYear && isSameMonth;
+      case 'year':
+        return isSameYear;
+      default:
+        return false;
+    }
+  }
+  // ----- Date handling
+  get dateFormat() {
+    const date = new Date(Date.UTC(3333, 10, 22));
+    const dateStr = new Intl.DateTimeFormat('en-US', {
+      year: 'numeric',
+      month: this.type !== 'year' ? 'numeric' : undefined,
+      day: this.type === 'date' || this.type === 'week' ? 'numeric' : undefined
+    }).format(date);
+    return dateStr.replace('22', 'dd').replace('11', 'mm').replace('3333', 'yyyy');
+  }
+  fromISOWeek(week) {
+    if (typeof week === 'string' || typeof week === 'number') {
+      const weekNumber = parseInt(week.toString(), 10);
+      return isNaN(weekNumber) ? new Date() : this.fromISOWeekNumber(weekNumber);
+    }
+    return week;
+  }
+  fromISOWeekNumber(weekNumber, year = new Date().getFullYear()) {
+    const refDate = new Date(Date.UTC(year, 0, 4)); // January 4th
+    const diffDays = (weekNumber - 1) * 7 - (refDate.getUTCDay() || 7) + 1;
+    const date = new Date(refDate);
+    date.setUTCDate(date.getUTCDate() + diffDays);
+    return date;
+  }
+  toISOWeek(date) {
+    const currentDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    currentDate.setUTCDate(currentDate.getUTCDate() + 4 - (currentDate.getUTCDay() || 7));
+    const firstDayOfYear = new Date(Date.UTC(currentDate.getUTCFullYear(), 0, 1));
+    return Math.ceil(((currentDate.getTime() - firstDayOfYear.getTime()) / 86400000 + 1) / 7);
+  }
+  static get is() { return "cat-datepicker"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["cat-datepicker.scss"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["cat-datepicker.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "requiredMarker": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "'none' | 'required' | 'optional' | 'none!' | 'optional!' | 'required!'",
+          "resolved": "\"none!\" | \"none\" | \"optional!\" | \"optional\" | \"required!\" | \"required\"",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Whether the label need a marker to shown if the input is required or optional."
+        },
+        "attribute": "required-marker",
+        "reflect": false,
+        "defaultValue": "'optional'"
+      },
+      "horizontal": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Whether the label is on top or left."
+        },
+        "attribute": "horizontal",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "autoComplete": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Hint for form autofill feature."
+        },
+        "attribute": "auto-complete",
+        "reflect": false
+      },
+      "clearable": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Whether the input should show a clear button."
+        },
+        "attribute": "clearable",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "disabled": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Whether the input is disabled."
+        },
+        "attribute": "disabled",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "hint": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string | string[]",
+          "resolved": "string | string[] | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Optional hint text(s) to be displayed with the input."
+        },
+        "attribute": "hint",
+        "reflect": false
+      },
+      "icon": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The name of an icon to be displayed in the input."
+        },
+        "attribute": "icon",
+        "reflect": false
+      },
+      "iconLeft": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Display the icon on the left."
+        },
+        "attribute": "icon-left",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "identifier": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "A unique identifier for the input."
+        },
+        "attribute": "identifier",
+        "reflect": false
+      },
+      "label": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "The label for the input."
+        },
+        "attribute": "label",
+        "reflect": false,
+        "defaultValue": "''"
+      },
+      "labelHidden": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Visually hide the label, but still show it to assistive technologies like screen readers."
+        },
+        "attribute": "label-hidden",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "max": {
+        "type": "any",
+        "mutable": false,
+        "complexType": {
+          "original": "number | string",
+          "resolved": "number | string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "A maximum value for date, time and numeric values."
+        },
+        "attribute": "max",
+        "reflect": false
+      },
+      "min": {
+        "type": "any",
+        "mutable": false,
+        "complexType": {
+          "original": "number | string",
+          "resolved": "number | string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "A minimum value for date, time and numeric values."
+        },
+        "attribute": "min",
+        "reflect": false
+      },
+      "name": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The name of the form control. Submitted with the form as part of a name/value pair."
+        },
+        "attribute": "name",
+        "reflect": false
+      },
+      "placeholder": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The placeholder text to display within the input."
+        },
+        "attribute": "placeholder",
+        "reflect": false
+      },
+      "textPrefix": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "A textual prefix to be displayed in the input."
+        },
+        "attribute": "text-prefix",
+        "reflect": false
+      },
+      "textSuffix": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "A textual suffix to be displayed in the input."
+        },
+        "attribute": "text-suffix",
+        "reflect": false
+      },
+      "readonly": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "The value is not editable."
+        },
+        "attribute": "readonly",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "required": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "A value is required or must be check for the form to be submittable."
+        },
+        "attribute": "required",
+        "reflect": false,
+        "defaultValue": "false"
+      },
+      "format": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "The date format after picker selection."
+        },
+        "attribute": "format",
+        "reflect": false,
+        "defaultValue": "'mm/dd/yyyy'"
+      },
+      "weekNumbers": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Whether the picker should show the week numbers."
+        },
+        "attribute": "week-numbers",
+        "reflect": false,
+        "defaultValue": "true"
+      },
+      "type": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "DatepickerType",
+          "resolved": "\"date\" | \"month\" | \"week\" | \"year\"",
+          "references": {
+            "DatepickerType": {
+              "location": "import",
+              "path": "./datepicker-type"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Type of datepicker ('date', 'week', 'month', 'year')."
+        },
+        "attribute": "type",
+        "reflect": false,
+        "defaultValue": "'date'"
+      },
+      "datesDisabled": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "Array<Date> | Array<string>",
+          "resolved": "Date[] | string[]",
+          "references": {
+            "Array": {
+              "location": "global"
+            },
+            "Date": {
+              "location": "global"
+            }
+          }
+        },
+        "required": true,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Dates that should be disabled inside the picker"
+        }
+      },
+      "value": {
+        "type": "string",
+        "mutable": true,
+        "complexType": {
+          "original": "string",
+          "resolved": "string | undefined",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The value of the control."
+        },
+        "attribute": "value",
+        "reflect": false
+      },
+      "errors": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean | string[] | ErrorMap",
+          "resolved": "boolean | string[] | undefined | { [key: string]: any; }",
+          "references": {
+            "ErrorMap": {
+              "location": "import",
+              "path": "../cat-form-hint/cat-form-hint"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The validation errors for this input. Will render a hint under the input\nwith the translated error message(s) `error.${key}`. If an object is\npassed, the keys will be used as error keys and the values translation\nparameters.\nIf the value is `true`, the input will be marked as invalid without any\nhints under the input."
+        },
+        "attribute": "errors",
+        "reflect": false
+      },
+      "errorUpdate": {
+        "type": "any",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean | number",
+          "resolved": "boolean | number",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Fine-grained control over when the errors are shown. Can be `false` to\nnever show errors, `true` to show errors on blur, or a number to show\nerrors on change with the given delay in milliseconds."
+        },
+        "attribute": "error-update",
+        "reflect": false,
+        "defaultValue": "0"
+      },
+      "nativeAttributes": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "{ [key: string]: string }",
+          "resolved": "undefined | { [key: string]: string; }",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "Attributes that will be added to the native HTML input element."
+        }
+      }
+    };
+  }
+  static get states() {
+    return {
+      "hasSlottedLabel": {},
+      "hasSlottedHint": {}
+    };
+  }
+  static get events() {
+    return [{
+        "method": "catChange",
+        "name": "catChange",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitted when the value is changed."
+        },
+        "complexType": {
+          "original": "InputEvent",
+          "resolved": "InputEvent",
+          "references": {
+            "InputEvent": {
+              "location": "global"
+            }
+          }
+        }
+      }, {
+        "method": "catFocus",
+        "name": "catFocus",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitted when the input received focus."
+        },
+        "complexType": {
+          "original": "FocusEvent",
+          "resolved": "FocusEvent",
+          "references": {
+            "FocusEvent": {
+              "location": "global"
+            }
+          }
+        }
+      }, {
+        "method": "catBlur",
+        "name": "catBlur",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emitted when the input loses focus."
+        },
+        "complexType": {
+          "original": "FocusEvent",
+          "resolved": "FocusEvent",
+          "references": {
+            "FocusEvent": {
+              "location": "global"
+            }
+          }
+        }
+      }];
+  }
+  static get methods() {
+    return {
+      "doFocus": {
+        "complexType": {
+          "signature": "(options?: FocusOptions) => Promise<void>",
+          "parameters": [{
+              "tags": [{
+                  "name": "param",
+                  "text": "options An optional object providing options to control aspects of\nthe focusing process."
+                }],
+              "text": "An optional object providing options to control aspects of\nthe focusing process."
+            }],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "FocusOptions": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Programmatically move focus to the input. Use this method instead of\n`input.focus()`.",
+          "tags": [{
+              "name": "param",
+              "text": "options An optional object providing options to control aspects of\nthe focusing process."
+            }]
+        }
+      },
+      "doBlur": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Programmatically remove focus from the input. Use this method instead of\n`input.blur()`.",
+          "tags": []
+        }
+      },
+      "doClick": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Programmatically simulate a click on the input.",
+          "tags": []
+        }
+      },
+      "clear": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Clear the input.",
+          "tags": []
+        }
+      }
+    };
+  }
+  static get elementRef() { return "hostElement"; }
+}
+//# sourceMappingURL=cat-datepicker.js.map