@progress/kendo-vue-dropdowns 3.5.0 → 3.5.1-dev.202208150613

package/dist/esm/common/ListDefaultItem.d.ts

@@ -0,0 +1,29 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface DefaultItemProps {
+    defaultItem?: any;
+    textField?: string;
+    selected: boolean;
+}
+/**
+ * @hidden
+ */
+export interface ListDefaultItemMethods extends Vue2type {
+    onMouseDown: (e: any) => void;
+    onClick: (e: any) => void;
+}
+/**
+ * @hidden
+ */
+declare let ListDefaultItemVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<ListDefaultItemMethods>, {}, RecordPropsDefinition<DefaultItemProps>>;
+/**
+ * @hidden
+ */
+declare const ListDefaultItem: DefineComponent<DefaultItemProps, any, {}, {}, ListDefaultItemMethods, {}, {}, {}, string, DefaultItemProps, DefaultItemProps, {}>;
+export { ListDefaultItem, ListDefaultItemVue2 };

package/dist/esm/common/ListDefaultItem.js

@@ -0,0 +1,62 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { classNames } from '@progress/kendo-vue-common';
+import { getItemValue } from './utils.js';
+/**
+ * @hidden
+ */
+
+var ListDefaultItemVue2 = {
+  name: 'list-default-item',
+  props: {
+    defaultItem: [Object, String],
+    textField: String,
+    selected: Boolean
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  methods: {
+    onMouseDown: function onMouseDown(e) {
+      e.preventDefault();
+    },
+    onClick: function onClick(e) {
+      this.$emit('defaultitemclick', e);
+    }
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var _a = this.$props,
+        selected = _a.selected,
+        defaultItem = _a.defaultItem,
+        textField = _a.textField;
+    return h("div", {
+      onClick: this.onClick,
+      on: this.v3 ? undefined : {
+        "click": this.onClick,
+        "mousedown": this.onMouseDown
+      },
+      onMousedown: this.onMouseDown,
+      style: {
+        position: 'unset'
+      },
+      "class": classNames('k-list-optionlabel', {
+        'k-selected': selected
+      })
+    }, [getItemValue(defaultItem, textField) || '']);
+  }
+};
+/**
+ * @hidden
+ */
+
+var ListDefaultItem = ListDefaultItemVue2;
+export { ListDefaultItem, ListDefaultItemVue2 };

package/dist/esm/common/ListFilter.d.ts

@@ -0,0 +1,46 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface ListFilterProps {
+    value?: string;
+    onChange?: any;
+    onKeyDown?: any;
+    size?: null | 'small' | 'medium' | 'large' | string;
+    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
+    fillMode?: null | 'solid' | 'flat' | 'outline' | string;
+}
+/**
+ * @hidden
+ */
+export interface ListFilterMethods extends Vue2type {
+    [key: string]: any;
+    onKeyDown: (e: any) => void;
+    onChange: (e: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface ListFilterState {
+    input: any;
+    inputRef: any;
+    v3: boolean;
+}
+/**
+ * @hidden
+ */
+export interface ListFilterAll extends ListFilterState, ListFilterMethods {
+}
+/**
+ * @hidden
+ */
+declare let ListFilterVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<ListFilterMethods>, {}, RecordPropsDefinition<ListFilterProps>>;
+/**
+ * @hidden
+ */
+declare const ListFilter: DefineComponent<ListFilterProps, any, {}, {}, ListFilterMethods, {}, {}, {}, string, ListFilterProps, ListFilterProps, {}>;
+export { ListFilter, ListFilterVue2 };

package/dist/esm/common/ListFilter.js

@@ -0,0 +1,112 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+var ref = allVue.ref;
+import { getRef, kendoThemeMaps, setRef } from '@progress/kendo-vue-common';
+var sizeMap = kendoThemeMaps.sizeMap,
+    roundedMap = kendoThemeMaps.roundedMap;
+/**
+ * @hidden
+ */
+
+var ListFilterVue2 = {
+  name: 'list-filter',
+  // @ts-ignore
+  emits: {
+    keydown: null,
+    change: null
+  },
+  props: {
+    value: String,
+    rounded: {
+      type: String,
+      default: 'medium',
+      validator: function validator(value) {
+        return ['small', 'medium', 'large', 'full'].includes(value);
+      }
+    },
+    fillMode: {
+      type: String,
+      default: 'solid',
+      validator: function validator(value) {
+        return ['solid', 'flat', 'outline'].includes(value);
+      }
+    },
+    size: {
+      type: String,
+      default: 'medium',
+      validator: function validator(value) {
+        return ['small', 'medium', 'large'].includes(value);
+      }
+    }
+  },
+  computed: {
+    spanClass: function spanClass() {
+      var _a;
+
+      var _b = this.$props,
+          size = _b.size,
+          rounded = _b.rounded,
+          fillMode = _b.fillMode;
+      return _a = {
+        'k-searchbox k-input': true
+      }, _a["k-input-".concat(sizeMap[size] || size)] = size, _a["k-rounded-".concat(roundedMap[rounded] || rounded)] = rounded, _a["k-input-".concat(fillMode)] = fillMode, _a;
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    var inputRef = ref(null);
+    return {
+      v3: v3,
+      inputRef: inputRef
+    };
+  },
+  methods: {
+    onKeyDown: function onKeyDown(e) {
+      this.$emit('keydown', e);
+    },
+    onChange: function onChange(e) {
+      this.$emit('change', e);
+    }
+  },
+  mounted: function mounted() {
+    this.input = getRef(this, 'input');
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    return h("span", {
+      "class": "k-list-filter"
+    }, [h("span", {
+      "class": this.spanClass
+    }, [h("span", {
+      "class": "k-input-icon k-icon k-i-search"
+    }), h("input", {
+      ref: setRef(this, 'input'),
+      type: "text",
+      attrs: this.v3 ? undefined : {
+        type: "text"
+      },
+      value: this.v3 ? this.$props.value || '' : null,
+      domProps: this.v3 ? undefined : {
+        "value": this.$props.value || ''
+      },
+      "class": "k-input-inner",
+      onInput: this.onChange,
+      on: this.v3 ? undefined : {
+        "input": this.onChange,
+        "keydown": this.onKeyDown
+      },
+      onKeydown: this.onKeyDown
+    })])]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var ListFilter = ListFilterVue2;
+export { ListFilter, ListFilterVue2 };

package/dist/esm/common/ListItem.d.ts

@@ -0,0 +1,71 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * Represents the props of the ListItem component.
+ */
+export interface ListItemProps {
+    /**
+     * Specifies the id that will be added to the list item element.
+     */
+    id?: string;
+    /**
+     * Represents the index of the list item element.
+     */
+    index: number;
+    /**
+     * Represents the data item of the list item element.
+     */
+    dataItem: any;
+    /**
+     * Sets the data item field that represents the item text. If the data contains only primitive values, do not define it.
+     */
+    textField?: string;
+    /**
+     * Indicates the focused state of the list item element.
+     */
+    focused: boolean;
+    /**
+     * Indicates the selected state of the list item element.
+     */
+    selected: boolean;
+    /**
+     * Fires when the list item is about to be rendered. Used to override the default appearance of the list item.
+     */
+    render?: any;
+    /**
+     * The `onClick` event handler of the list item element.
+     */
+    onClick?: (index: number, event: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface ListItemMethods {
+    [key: string]: any;
+    handleClick: (e: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface ListItemComputed {
+    [key: string]: any;
+    itemClass: object;
+}
+/**
+ * @hidden
+ */
+export interface ListItemAll extends Vue2type, ListItemMethods, ListItemComputed {
+    itemClass: object;
+}
+/**
+ * @hidden
+ */
+declare let ListItemVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<ListItemAll>, ListItemComputed, RecordPropsDefinition<ListItemProps>>;
+/**
+ * @hidden
+ */
+declare const ListItem: DefineComponent<ListItemProps, any, {}, {}, ListItemMethods, {}, {}, {}, string, ListItemProps, ListItemProps, {}>;
+export { ListItem, ListItemVue2 };

package/dist/esm/common/ListItem.js

@@ -0,0 +1,105 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { classNames, getTemplate } from '@progress/kendo-vue-common';
+import { getItemValue } from './utils.js';
+/**
+ * @hidden
+ */
+
+var ListItemVue2 = {
+  name: 'list-item',
+  props: {
+    id: String,
+    index: Number,
+    dataItem: [Object, String, Number],
+    textField: String,
+    focused: Boolean,
+    selected: Boolean,
+    render: Object
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  computed: {
+    itemClass: function itemClass() {
+      return {
+        'k-list-item': true,
+        'k-selected': this.$props.selected,
+        'k-focus': this.$props.focused
+      };
+    }
+  },
+  methods: {
+    handleClick: function handleClick(e) {
+      this.$emit('itemclick', this.$props.index, e);
+    }
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var selected = this.$props.selected;
+    var defaultRendering = h("li", {
+      id: this.$props.id,
+      attrs: this.v3 ? undefined : {
+        id: this.$props.id,
+        role: "option",
+        "aria-selected": selected
+      },
+      role: "option",
+      "aria-selected": selected,
+      "class": classNames('k-list-item', {
+        'k-selected': selected,
+        'k-focus': this.$props.focused
+      }),
+      onClick: this.handleClick,
+      on: this.v3 ? undefined : {
+        "click": this.handleClick
+      },
+      style: {
+        position: 'unset'
+      }
+    }, [h("span", {
+      "class": "k-list-item-text"
+    }, [getItemValue(this.$props.dataItem, this.$props.textField).toString()])]);
+    return getTemplate.call(this, {
+      h: h,
+      template: this.$props.render,
+      defaultRendering: defaultRendering,
+      additionalProps: __assign(__assign({}, this.$props), {
+        itemClass: this.itemClass
+      }),
+      additionalListeners: {
+        click: this.handleClick
+      }
+    });
+  }
+};
+/**
+ * @hidden
+ */
+
+var ListItem = ListItemVue2;
+export { ListItem, ListItemVue2 };

package/dist/esm/common/Navigation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hidden
+ */
+export declare class Navigation {
+    navigate(args: {
+        keyCode: number;
+        current: number;
+        max: number;
+        min: number;
+    }): number;
+    private next;
+}

package/dist/esm/common/Navigation.js

@@ -0,0 +1,34 @@
+import { isPresent } from './utils.js';
+import { Keys } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+var Navigation = /** @class */ (function () {
+    function Navigation() {
+    }
+    Navigation.prototype.navigate = function (args) {
+        var keyCode = args.keyCode;
+        if (keyCode === Keys.up || keyCode === Keys.left) {
+            return this.next({ current: args.current, min: args.min, max: args.max, step: -1 });
+        }
+        else if (keyCode === Keys.down || keyCode === Keys.right) {
+            return this.next({ current: args.current, min: args.min, max: args.max, step: 1 });
+        }
+        else if (keyCode === Keys.home) {
+            return 0;
+        }
+        else if (keyCode === Keys.end) {
+            return args.max;
+        }
+    };
+    Navigation.prototype.next = function (args) {
+        if (!isPresent(args.current)) {
+            return args.min;
+        }
+        else {
+            return Math.min(args.max, Math.max(args.current + args.step, args.min));
+        }
+    };
+    return Navigation;
+}());
+export { Navigation };

package/dist/esm/common/SearchBar.d.ts

@@ -0,0 +1,65 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => SearchBarData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface SearchBarProps {
+    value: string;
+    id?: string;
+    placeholder?: string;
+    tabIndex?: number;
+    size?: number;
+    suggestedText?: string;
+    focused?: boolean;
+    onKeydown?: any;
+    onFocus?: any;
+    onBlur?: any;
+    disabled?: boolean;
+    readOnly?: boolean;
+    expanded?: boolean;
+    owns?: string;
+    name?: string;
+    activedescendant?: string;
+    describedby?: string;
+    clearButton?: boolean;
+    clearButtonClick?: any;
+    accessKey?: string;
+    ariaLabelledBy?: string;
+}
+/**
+ * @hidden
+ */
+export interface SearchBarMethods extends Vue2type {
+    onChange: (e: any) => void;
+    onBlur: (e: any) => void;
+    onFocus: (e: any) => void;
+    onKeyDown: (e: any) => void;
+    clearButtonClick: (e: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface SearchBarData {
+    input: any;
+    prevValue: string;
+    prevSuggestedText: string;
+    inputRef: any;
+    v3: boolean;
+}
+/**
+ * @hidden
+ */
+export interface SearchBarAll extends SearchBarMethods, SearchBarData {
+}
+/**
+ * @hidden
+ */
+declare let SearchBarVue2: ComponentOptions<Vue2type, DefaultData<SearchBarData>, DefaultMethods<SearchBarAll>, {}, RecordPropsDefinition<SearchBarProps>>;
+/**
+ * @hidden
+ */
+declare const SearchBar: DefineComponent<SearchBarProps, any, SearchBarData, {}, SearchBarMethods, {}, {}, {}, string, SearchBarProps, SearchBarProps, {}>;
+export { SearchBar, SearchBarVue2 };