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

package/dist/esm/Chip/ChipList.js

@@ -0,0 +1,263 @@
+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';
+var ref = allVue.ref;
+import { getTabIndex, classNames, getListeners, templateRendering, getTemplate, validatePackage, kendoThemeMaps, setRef } from '@progress/kendo-vue-common';
+import { selectionReducer } from './selection-reducer.js';
+import { focusReducer } from './focus-reducer.js';
+import { dataReducer } from './data-reducer.js';
+import { Chip } from './Chip.js';
+import { packageMetadata } from '../package-metadata.js';
+/**
+ * @hidden
+ */
+
+var ChipListVue2 = {
+  name: 'KendoVueChipList',
+  props: {
+    id: String,
+    tabIndex: Number,
+    dataItems: Array,
+    defaultDataItems: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    value: [Object, Array, String, Number],
+    defaultValue: {
+      type: [Object, Array, String, Number],
+      default: function _default() {
+        return null;
+      }
+    },
+    size: {
+      type: String,
+      default: 'medium'
+    },
+    rounded: {
+      type: String,
+      default: 'medium'
+    },
+    fillMode: {
+      type: String,
+      default: 'solid',
+      validator: function validator(value) {
+        return [null, 'flat', 'outline', 'solid'].includes(value);
+      }
+    },
+    selection: {
+      type: String,
+      default: function _default() {
+        return 'none';
+      }
+    },
+    textField: {
+      type: String,
+      default: function _default() {
+        return 'text';
+      }
+    },
+    valueField: {
+      type: String,
+      default: function _default() {
+        return 'value';
+      }
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    dir: {
+      type: String,
+      default: function _default() {
+        return 'ltr';
+      }
+    },
+    chip: [String, Function, Object],
+    ariaLabelledBy: String,
+    ariaDescribedBy: String
+  },
+  provide: function provide() {
+    return {
+      kendoSelection: this.currentValue,
+      kendoFocused: this.currentFocused,
+      kendoDataItems: this.computedDataItems,
+      handleDispatchDataItems: this.handleDispatchDataItems,
+      handleDispatchSelection: this.handleDispatchSelection,
+      handleDispatchFocus: this.handleDispatchFocus
+    };
+  },
+  created: function created() {
+    validatePackage(packageMetadata);
+    this.currentDataItems = this.$props.dataItems || this.$props.defaultDataItems;
+    this.currentValue.value = this.$props.value || this.$props.defaultValue;
+  },
+  data: function data() {
+    return {
+      currentDataItems: [],
+      currentDir: 'ltr',
+      isRtl: false,
+      currentFocused: {
+        value: false
+      },
+      currentValue: {
+        value: null
+      }
+    };
+  },
+  mounted: function mounted() {
+    this.chipList = this.v3 ? this.chipListRef : this.$refs.chipList;
+    this.currentDir = this.$props.dir !== undefined ? this.$props.dir : this.$el && getComputedStyle(this.$el).direction === 'rtl' || false;
+    this.isRtl = this.currentDir === 'rtl';
+  },
+  computed: {
+    computedDataItems: function computedDataItems() {
+      return this.$props.dataItems || this.currentDataItems;
+    },
+    computedValue: function computedValue() {
+      return this.$props.value || this.currentValue.value;
+    },
+    items: function items() {
+      return this.computedDataItems.reduce(this.itemsReducer, []);
+    }
+  },
+  methods: {
+    handleDispatchSelection: function handleDispatchSelection(action) {
+      var newState = selectionReducer(this.computedValue, __assign(__assign({}, action), {
+        selection: this.$props.selection,
+        state: this.computedValue
+      }));
+      this.handleChange(newState, action.event);
+      this.currentValue.value = newState;
+    },
+    handleDispatchFocus: function handleDispatchFocus(action) {
+      var newState = focusReducer(action.payload, __assign(__assign({}, action), {
+        items: this.items
+      }));
+      this.currentFocused.value = newState;
+    },
+    handleDispatchDataItems: function handleDispatchDataItems(action) {
+      var newState = dataReducer(this.computedDataItems, __assign(__assign({}, action), {
+        state: this.computedDataItems,
+        valueField: this.$props.valueField
+      }));
+      this.handleDataChange(newState, action.event);
+      this.currentDataItems = newState;
+    },
+    handleChange: function handleChange(newValue, event) {
+      if (this.$el) {
+        this.$emit('change', {
+          value: newValue,
+          target: this.$el,
+          event: event
+        });
+      }
+    },
+    handleDataChange: function handleDataChange(newData, event) {
+      if (this.$el) {
+        this.$emit('datachange', {
+          value: newData,
+          target: this.$el,
+          event: event
+        });
+      }
+    },
+    itemsReducer: function itemsReducer(acc, current) {
+      acc.push(current[this.$props.valueField || this.$props.valueField]);
+      return acc;
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    var chipListRef = ref(null);
+    return {
+      v3: v3,
+      chipListRef: chipListRef
+    };
+  },
+  render: function render(createElement) {
+    var _a;
+
+    var h = gh || createElement;
+    var size = this.$props.size;
+    return h("div", {
+      ref: setRef(this, 'chipList'),
+      role: 'listbox',
+      attrs: this.v3 ? undefined : {
+        role: 'listbox',
+        id: this.$props.id,
+        dir: this.currentDir,
+        tabindex: getTabIndex(this.$props.tabIndex, this.$props.disabled, undefined),
+        "aria-labelledby": this.$props.ariaLabelledBy,
+        "aria-describedby": this.$props.ariaDescribedBy
+      },
+      id: this.$props.id,
+      dir: this.currentDir,
+      style: this.$props.style,
+      tabindex: getTabIndex(this.$props.tabIndex, this.$props.disabled, undefined),
+      "class": classNames('k-chip-list', (_a = {}, _a["k-chip-list-".concat(kendoThemeMaps.sizeMap[size] || size)] = size, _a['k-rtl'] = this.currentDir === 'rtl', _a['k-selection-single'] = this.$props.selection === 'single', _a['k-selection-multiple'] = this.$props.selection === 'multiple', _a['k-disabled'] = this.$props.disabled, _a)),
+      "aria-labelledby": this.$props.ariaLabelledBy,
+      "aria-describedby": this.$props.ariaDescribedBy
+    }, [this.computedDataItems.map(function (item) {
+      var chipTemplate = templateRendering.call(this, this.$props.chip, getListeners.call(this));
+      var chipDefaultRendering = // @ts-ignore  function children
+      h(Chip, {
+        role: 'option',
+        attrs: this.v3 ? undefined : {
+          role: 'option',
+          dataItem: item,
+          text: item[this.$props.textField],
+          value: item[this.$props.valueField],
+          size: this.$props.size,
+          rounded: this.$props.rounded,
+          fillMode: this.$props.fillMode
+        },
+        dataItem: item,
+        key: item[this.$props.valueField],
+        text: item[this.$props.textField],
+        value: item[this.$props.valueField],
+        size: this.$props.size,
+        rounded: this.$props.rounded,
+        fillMode: this.$props.fillMode
+      });
+      return getTemplate.call(this, {
+        h: h,
+        template: chipTemplate,
+        defaultRendering: chipDefaultRendering,
+        additionalProps: {
+          dataItem: item,
+          key: item[this.$props.valueField],
+          text: item[this.$props.textField],
+          value: item[this.$props.valueField],
+          size: this.$props.size
+        }
+      });
+    }, this)]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var ChipList = ChipListVue2;
+export { ChipList, ChipListVue2 };

package/dist/esm/Chip/data-reducer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @hidden
+ */
+export declare enum DATA_ACTION {
+    remove = "remove",
+    add = "add",
+    reorder = "reorder"
+}
+/**
+ * @hidden
+ */
+export declare type DataAction = {
+    type: DATA_ACTION;
+    payload?: any;
+    valueField: string;
+    event?: any;
+};
+/**
+ * @hidden
+ */
+export declare const dataReducer: (state: any, action: DataAction) => any;

package/dist/esm/Chip/data-reducer.js

@@ -0,0 +1,34 @@
+/**
+ * @hidden
+ */
+export var DATA_ACTION;
+
+(function (DATA_ACTION) {
+  DATA_ACTION["remove"] = "remove";
+  DATA_ACTION["add"] = "add";
+  DATA_ACTION["reorder"] = "reorder";
+})(DATA_ACTION || (DATA_ACTION = {}));
+/**
+ * @hidden
+ */
+
+
+export var dataReducer = function dataReducer(state, action) {
+  switch (action.type) {
+    case DATA_ACTION.add:
+      // TODO v2
+      break;
+
+    case DATA_ACTION.remove:
+      return state.filter(function (i) {
+        return i[action.valueField] !== action.payload;
+      });
+
+    case DATA_ACTION.reorder:
+      // TODO v2
+      break;
+
+    default:
+      return state;
+  }
+};

package/dist/esm/Chip/focus-reducer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @hidden
+ */
+export declare enum FOCUS_ACTION {
+    next = "next",
+    prev = "prev",
+    current = "current",
+    reset = "reset"
+}
+/**
+ * @hidden
+ */
+export declare type FocusAction = {
+    type: FOCUS_ACTION;
+    payload: string;
+    items: string[];
+    target?: any;
+    event?: any;
+    state?: any;
+};
+/**
+ * @hidden
+ */
+export declare const focusReducer: (state: any, action: FocusAction) => any;

package/dist/esm/Chip/focus-reducer.js

@@ -0,0 +1,38 @@
+/**
+ * @hidden
+ */
+export var FOCUS_ACTION;
+
+(function (FOCUS_ACTION) {
+  FOCUS_ACTION["next"] = "next";
+  FOCUS_ACTION["prev"] = "prev";
+  FOCUS_ACTION["current"] = "current";
+  FOCUS_ACTION["reset"] = "reset";
+})(FOCUS_ACTION || (FOCUS_ACTION = {}));
+/**
+ * @hidden
+ */
+
+
+export var focusReducer = function focusReducer(state, action) {
+  var currentIndex = action.items.findIndex(function (i) {
+    return i === state;
+  });
+
+  switch (action.type) {
+    case FOCUS_ACTION.next:
+      return currentIndex === action.items.length - 1 ? state : action.items[currentIndex + 1];
+
+    case FOCUS_ACTION.prev:
+      return currentIndex === 0 ? state : action.items[currentIndex - 1];
+
+    case FOCUS_ACTION.current:
+      return action.payload;
+
+    case FOCUS_ACTION.reset:
+      return null;
+
+    default:
+      return state;
+  }
+};

package/dist/esm/Chip/selection-reducer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @hidden
+ */
+export declare enum SELECTION_TYPE {
+    single = "single",
+    multiple = "multiple",
+    none = "none"
+}
+/**
+ * @hidden
+ */
+export declare enum SELECTION_ACTION {
+    toggle = "toggle",
+    remove = "remove"
+}
+/**
+ * @hidden
+ */
+export declare type SelectionAction = {
+    type?: SELECTION_ACTION;
+    selection: SELECTION_TYPE;
+    payload?: string;
+    event?: any;
+    state?: any;
+};
+/**
+ * @hidden
+ */
+export declare const selectionReducer: (state: any, action: SelectionAction) => any;

package/dist/esm/Chip/selection-reducer.js

@@ -0,0 +1,102 @@
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * @hidden
+ */
+
+
+export var SELECTION_TYPE;
+
+(function (SELECTION_TYPE) {
+  SELECTION_TYPE["single"] = "single";
+  SELECTION_TYPE["multiple"] = "multiple";
+  SELECTION_TYPE["none"] = "none";
+})(SELECTION_TYPE || (SELECTION_TYPE = {}));
+/**
+ * @hidden
+ */
+
+
+export var SELECTION_ACTION;
+
+(function (SELECTION_ACTION) {
+  SELECTION_ACTION["toggle"] = "toggle";
+  SELECTION_ACTION["remove"] = "remove";
+})(SELECTION_ACTION || (SELECTION_ACTION = {}));
+/**
+ * @hidden
+ */
+
+
+export var selectionReducer = function selectionReducer(state, action) {
+  switch (action.selection) {
+    case SELECTION_TYPE.single:
+      switch (action.type) {
+        case SELECTION_ACTION.toggle:
+          {
+            if (!Array.isArray(state) || state === null) {
+              return action.payload === state ? null : action.payload;
+            }
+
+            throw new Error('State cannot be an array in single selection');
+          }
+
+        case SELECTION_ACTION.remove:
+          {
+            return action.payload === state ? null : state;
+          }
+
+        default:
+          return state;
+      }
+
+    case SELECTION_TYPE.multiple:
+      switch (action.type) {
+        case SELECTION_ACTION.toggle:
+          {
+            if (Array.isArray(state)) {
+              return state.some(function (i) {
+                return i === action.payload;
+              }) ? state.filter(function (i) {
+                return i !== action.payload;
+              }) : __spreadArray(__spreadArray([], state, true), [action.payload], false);
+            }
+
+            if (state === null) {
+              return [action.payload];
+            }
+
+            throw new Error('State cannot be non-array in multiple selection');
+          }
+
+        case SELECTION_ACTION.remove:
+          {
+            if (Array.isArray(state)) {
+              return state.some(function (i) {
+                return i === action.payload;
+              }) ? state.filter(function (i) {
+                return i !== action.payload;
+              }) : __spreadArray(__spreadArray([], state, true), [action.payload], false);
+            }
+
+            return state;
+          }
+
+        default:
+          return state;
+      }
+
+    case SELECTION_TYPE.none:
+      return null;
+
+    default:
+      return state;
+  }
+};

package/dist/esm/FloatingActionButton/FloatingActionButton.d.ts

@@ -0,0 +1,49 @@
+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;
+};
+import { FloatingActionButtonProps } from './interfaces/FloatingActionButtonProps';
+/**
+ * @hidden
+ */
+export interface FloatingActionButtonMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface FloatingActionButtonState {
+    v3: boolean;
+    target: any;
+    currentRtl: boolean;
+}
+/**
+ * @hidden
+ */
+export interface FloatingActionButtonData {
+    currentOpened: boolean;
+    currentFocused: boolean;
+    focusedIndex: number;
+}
+/**
+ * @hidden
+ */
+export interface FloatingActionButtonComputed {
+    [key: string]: any;
+    computedOpened: boolean;
+}
+/**
+ * @hidden
+ */
+export interface FloatingActionButtonAll extends FloatingActionButtonMethods, FloatingActionButtonState, FloatingActionButtonData, FloatingActionButtonComputed, Vue2type {
+}
+/**
+ * @hidden
+ */
+declare let FloatingActionButtonVue2: ComponentOptions<Vue2type, DefaultData<FloatingActionButtonData>, DefaultMethods<FloatingActionButtonAll>, FloatingActionButtonComputed, RecordPropsDefinition<FloatingActionButtonProps>>;
+/**
+ * @hidden
+ */
+declare const FloatingActionButton: DefineComponent<FloatingActionButtonProps, any, FloatingActionButtonData, FloatingActionButtonComputed, FloatingActionButtonMethods, {}, {}, {}, string, FloatingActionButtonProps, FloatingActionButtonProps, {}>;
+export { FloatingActionButton, FloatingActionButtonVue2 };