@progress/kendo-vue-gauges 2.7.1 → 2.7.3-dev.202201070829

package/dist/es/CircularGauge.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent } from './additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { CircularGaugeProps } from './CircularGaugeProps';
+import { ArcGaugeState, ArcGaugeComputed, ArcGaugeMethods, ArcGaugeData } from './ArcGauge';
+/**
+ * @hidden
+ */
+export interface CircularGaugeState extends ArcGaugeState {
+}
+/**
+ * @hidden
+ */
+export interface CircularGaugeComputed extends ArcGaugeComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface CircularGaugeMethods extends ArcGaugeMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface CircularGaugeData extends ArcGaugeData {
+}
+/**
+ * @hidden
+ */
+export interface CircularGaugeAll extends Vue, CircularGaugeMethods, CircularGaugeData, CircularGaugeComputed, CircularGaugeState {
+}
+declare let CircularGauge: ComponentOptions<CircularGaugeAll, DefaultData<CircularGaugeData>, DefaultMethods<CircularGaugeAll>, CircularGaugeComputed, RecordPropsDefinition<CircularGaugeProps>>;
+declare const CircularGaugeVue3: DefineComponent<CircularGaugeProps, any, CircularGaugeData, CircularGaugeComputed, CircularGaugeMethods, {}, {}, {}, string, CircularGaugeProps, CircularGaugeProps, {}>;
+export { CircularGauge, CircularGaugeVue3 };

package/dist/es/CircularGauge.js

@@ -0,0 +1,33 @@
+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;
+import { ArcGauge } from './ArcGauge';
+import { CircularGauge as KendoCircularGauge } from '@progress/kendo-charts'; // tslint:enable:max-line-length
+
+var CircularGauge = __assign(__assign({}, ArcGauge), {
+  name: 'KendoCircularGauge',
+  created: function created() {
+    this.gaugeType = KendoCircularGauge;
+    this.arcCenterStyles = {};
+  }
+});
+
+var CircularGaugeVue3 = CircularGauge;
+export { CircularGauge, CircularGaugeVue3 };

package/dist/es/CircularGaugeProps.d.ts

@@ -0,0 +1,17 @@
+import { ArcGaugeProps } from './ArcGaugeProps';
+import { CircularScale } from './types/circular-scale.interface';
+import { ColorRange } from './types/color-range.interface';
+/**
+ * Represents the props of the [KendoReact CircularGauge component]({% slug overview_circulargauge_gauges %}).
+ */
+export interface CircularGaugeProps extends ArcGaugeProps {
+    /**
+     * The color ranges of the value pointer
+     * ([see example]({% slug colorranges_circulargauge %})).
+     */
+    colors?: ColorRange[];
+    /**
+     * The scale options of the CircularGauge.
+     */
+    scale?: CircularScale;
+}

package/dist/es/GaugeContext.d.ts

@@ -0,0 +1 @@
+

package/dist/es/GaugeContext.js

@@ -0,0 +1,12 @@
+// import { Store } from './store/store';
+// /**
+//  * @hidden
+//  */
+// export interface GaugeContextType {
+//     observersStore: Store;
+// }
+// /**
+//  * @hidden
+//  */
+// export const GaugeContext = React.createContext<GaugeContextType | null>(null);
+// GaugeContext.displayName = 'GaugeContext';

package/dist/es/LinearGauge.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent } from './additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { LinearGaugeProps } from './LinearGaugeProps';
+/**
+ * @hidden
+ */
+export interface LinearGaugeState {
+    baseGauge: any;
+}
+/**
+ * @hidden
+ */
+export interface LinearGaugeComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface LinearGaugeMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface LinearGaugeData {
+}
+/**
+ * @hidden
+ */
+export interface LinearGaugeAll extends Vue, LinearGaugeMethods, LinearGaugeData, LinearGaugeComputed, LinearGaugeState {
+}
+declare let LinearGauge: ComponentOptions<LinearGaugeAll, DefaultData<LinearGaugeData>, DefaultMethods<LinearGaugeAll>, LinearGaugeComputed, RecordPropsDefinition<LinearGaugeProps>>;
+declare const LinearGaugeVue3: DefineComponent<LinearGaugeProps, any, LinearGaugeData, LinearGaugeComputed, LinearGaugeMethods, {}, {}, {}, string, LinearGaugeProps, LinearGaugeProps, {}>;
+export { LinearGauge, LinearGaugeVue3 };

package/dist/es/LinearGauge.js

@@ -0,0 +1,113 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { BaseGauge } from './BaseGauge';
+import { LinearGauge as KendoLinearGauge } from '@progress/kendo-charts';
+import { Group } from '@progress/kendo-drawing';
+import { getDefaultSlots } from '@progress/kendo-vue-common'; // tslint:enable:max-line-length
+
+var LinearGauge = {
+  name: 'KendoLinearGauge',
+  props: {
+    dir: String,
+    renderAs: {
+      type: String,
+      default: 'svg',
+      validator: function validator(value) {
+        return ['svg', 'canvas'].includes(value);
+      }
+    },
+    gaugeConstructor: [Object, Function],
+    pointer: {
+      type: [Object, Array],
+      default: undefined
+    },
+    scale: {
+      type: Object,
+      default: undefined
+    }
+  },
+  mounted: function mounted() {
+    this._baseGauge = this.v3 ? this.baseGaugeRef : this.$refs.baseGauge;
+  },
+  updated: function updated() {
+    this._baseGauge = this.v3 ? this.baseGaugeRef : this.$refs.baseGauge;
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    var defaultSlots = getDefaultSlots(this);
+    return (// @ts-ignore  function children
+      h(BaseGauge, {
+        deriveOptionsFromParent: this.deriveOptionsFromParent,
+        attrs: this.v3 ? undefined : {
+          deriveOptionsFromParent: this.deriveOptionsFromParent,
+          gaugeConstructor: KendoLinearGauge,
+          getTarget: this.getTarget
+        },
+        ref: this.v3 ? function (el) {
+          _this.baseGaugeRef = el;
+        } : 'baseGauge',
+        gaugeConstructor: KendoLinearGauge,
+        getTarget: this.getTarget,
+        "class": 'k-gauge'
+      }, this.v3 ? function () {
+        return [defaultSlots];
+      } : [defaultSlots])
+    );
+  },
+  methods: {
+    gaugeInstance: function gaugeInstance() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.gaugeInstance;
+      }
+
+      return null;
+    },
+    surface: function surface() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.surface;
+      }
+
+      return null;
+    },
+    element: function element() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.element;
+      }
+
+      return null;
+    },
+    exportVisual: function exportVisual(options) {
+      if (this.gaugeInstance !== null) {
+        return Promise.resolve(this.gaugeInstance.exportVisual(options));
+      }
+
+      return Promise.resolve(new Group());
+    },
+    getTarget: function getTarget() {
+      return this;
+    },
+    deriveOptionsFromParent: function deriveOptionsFromParent(options) {
+      var _a = this.$props,
+          pointer = _a.pointer,
+          scale = _a.scale;
+      return Object.assign({}, options, {
+        pointer: pointer,
+        scale: scale
+      });
+    }
+  }
+};
+var LinearGaugeVue3 = LinearGauge;
+export { LinearGauge, LinearGaugeVue3 };

package/dist/es/LinearGaugeProps.d.ts

@@ -0,0 +1,15 @@
+import { BaseGaugeProps } from './BaseGaugeProps';
+import { LinearPointer, LinearScale } from './types';
+/**
+ * Represents the props of the [KendoReact LinearGauge component]({% slug overview_lineargauge_gauges %}).
+ */
+export interface LinearGaugeProps extends BaseGaugeProps {
+    /**
+     * The configuration of the pointers ([see example]({% slug multiplepointers_lineargauge %})).
+     */
+    pointer: LinearPointer | LinearPointer[];
+    /**
+     * The configuration of the scale.
+     */
+    scale?: LinearScale;
+}

package/dist/es/RadialGauge.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent } from './additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { RadialGaugeProps } from './RadialGaugeProps';
+/**
+ * @hidden
+ */
+export interface RadialGaugeState {
+    baseGauge: any;
+}
+/**
+ * @hidden
+ */
+export interface RadialGaugeComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RadialGaugeMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RadialGaugeData {
+}
+/**
+ * @hidden
+ */
+export interface RadialGaugeAll extends Vue, RadialGaugeMethods, RadialGaugeData, RadialGaugeComputed, RadialGaugeState {
+}
+declare let RadialGauge: ComponentOptions<RadialGaugeAll, DefaultData<RadialGaugeData>, DefaultMethods<RadialGaugeAll>, RadialGaugeComputed, RecordPropsDefinition<RadialGaugeProps>>;
+declare const RadialGaugeVue3: DefineComponent<RadialGaugeProps, any, RadialGaugeData, RadialGaugeComputed, RadialGaugeMethods, {}, {}, {}, string, RadialGaugeProps, RadialGaugeProps, {}>;
+export { RadialGauge, RadialGaugeVue3 };

package/dist/es/RadialGauge.js

@@ -0,0 +1,114 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { BaseGauge } from './BaseGauge';
+import { RadialGauge as KendoRadialGauge } from '@progress/kendo-charts';
+import { Group } from '@progress/kendo-drawing';
+import { getDefaultSlots } from '@progress/kendo-vue-common'; // tslint:enable:max-line-length
+
+var RadialGauge = {
+  name: 'KendoRadialGauge',
+  props: {
+    dir: String,
+    renderAs: {
+      type: String,
+      default: 'svg',
+      validator: function validator(value) {
+        return ['svg', 'canvas'].includes(value);
+      }
+    },
+    gaugeConstructor: [Object, Function],
+    pointer: {
+      type: [Object, Array],
+      default: undefined
+    },
+    scale: {
+      type: Object,
+      default: undefined
+    }
+  },
+  mounted: function mounted() {
+    this._baseGauge = this.v3 ? this.baseGaugeRef : this.$refs.baseGauge;
+  },
+  updated: function updated() {
+    this._baseGauge = this.v3 ? this.baseGaugeRef : this.$refs.baseGauge;
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    var defaultSlots = getDefaultSlots(this);
+    var className = this.$props.className;
+    return (// @ts-ignore  function children
+      h(BaseGauge, {
+        deriveOptionsFromParent: this.deriveOptionsFromParent,
+        attrs: this.v3 ? undefined : {
+          deriveOptionsFromParent: this.deriveOptionsFromParent,
+          gaugeConstructor: KendoRadialGauge,
+          getTarget: this.getTarget
+        },
+        ref: this.v3 ? function (el) {
+          _this.baseGaugeRef = el;
+        } : 'baseGauge',
+        gaugeConstructor: KendoRadialGauge,
+        getTarget: this.getTarget,
+        "class": 'k-gauge'
+      }, this.v3 ? function () {
+        return [defaultSlots];
+      } : [defaultSlots])
+    );
+  },
+  methods: {
+    gaugeInstance: function gaugeInstance() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.gaugeInstance;
+      }
+
+      return null;
+    },
+    surface: function surface() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.surface;
+      }
+
+      return null;
+    },
+    element: function element() {
+      if (this._baseGauge !== null) {
+        return this._baseGauge.element;
+      }
+
+      return null;
+    },
+    exportVisual: function exportVisual(options) {
+      if (this.gaugeInstance !== null) {
+        return Promise.resolve(this.gaugeInstance.exportVisual(options));
+      }
+
+      return Promise.resolve(new Group());
+    },
+    getTarget: function getTarget() {
+      return this;
+    },
+    deriveOptionsFromParent: function deriveOptionsFromParent(options) {
+      var _a = this.$props,
+          pointer = _a.pointer,
+          scale = _a.scale;
+      return Object.assign({}, options, {
+        pointer: pointer,
+        scale: scale
+      });
+    }
+  }
+};
+var RadialGaugeVue3 = RadialGauge;
+export { RadialGauge, RadialGaugeVue3 };

package/dist/es/RadialGaugeProps.d.ts

@@ -0,0 +1,15 @@
+import { BaseGaugeProps } from './BaseGaugeProps';
+import { RadialPointer, RadialScale } from './types';
+/**
+ * Represents the props of the [KendoReact RadialGauge component]({% slug overview_radialgauge_gauges %}).
+ */
+export interface RadialGaugeProps extends BaseGaugeProps {
+    /**
+     * The configuration of the pointers ([see example]({% slug multiplepointers_radialgauge %})).
+     */
+    pointer: RadialPointer | RadialPointer[];
+    /**
+     * The configuration of the scale.
+     */
+    scale?: RadialScale;
+}

package/dist/es/additionalTypes.ts

@@ -0,0 +1,3 @@
+// @ts-ignore
+import { DefineComponent } from 'vue';
+export { DefineComponent };

package/dist/es/common/gauges.d.ts

@@ -0,0 +1 @@
+

package/dist/es/common/gauges.js

@@ -0,0 +1,5 @@
+// import { ArcGauge } from './../ArcGauge';
+// import { LinearGauge } from './../LinearGauge';
+// import { RadialGauge } from './../RadialGauge';
+// type Gauges = ArcGauge | LinearGauge | RadialGauge;
+// export { Gauges };

package/dist/es/main.d.ts

@@ -1 +1,10 @@
-export {};
+import { ArcGauge } from './ArcGauge';
+import { ArcGaugeProps } from './ArcGaugeProps';
+import { CircularGauge } from './CircularGauge';
+import { CircularGaugeProps } from './CircularGaugeProps';
+import { LinearGauge } from './LinearGauge';
+import { LinearGaugeProps } from './LinearGaugeProps';
+import { RadialGauge } from './RadialGauge';
+import { RadialGaugeProps } from './RadialGaugeProps';
+export * from './types';
+export { ArcGauge, ArcGaugeProps, CircularGauge, CircularGaugeProps, LinearGauge, LinearGaugeProps, RadialGauge, RadialGaugeProps };

package/dist/es/main.js

@@ -1,8 +1,7 @@
-// import { ArcGauge } from './ArcGauge';
-// import { ArcGaugeProps } from './ArcGaugeProps';
-// import { CircularGauge } from './CircularGauge';
-// import { CircularGaugeProps } from './CircularGaugeProps';
-// import { LinearGauge } from './LinearGauge';
-// import { LinearGaugeProps } from './LinearGaugeProps';
-// import { RadialGauge } from './RadialGauge';
-// import { RadialGaugeProps } from './RadialGaugeProps';
+import { ArcGauge } from './ArcGauge';
+import { CircularGauge } from './CircularGauge';
+import { LinearGauge } from './LinearGauge';
+import { RadialGauge } from './RadialGauge';
+// export * from './common/gauges';
+export * from './types';
+export { ArcGauge, CircularGauge, LinearGauge, RadialGauge };

package/dist/es/package-metadata.js

@@ -5,7 +5,7 @@ export var packageMetadata = {
     name: '@progress/kendo-vue-gauges',
     productName: 'Kendo UI for Vue',
     productCodes: ['KENDOUIVUE', 'KENDOUICOMPLETE'],
-    publishDate: 1640003918,
+    publishDate: 1641543705,
     version: '',
     licensingDocsUrl: 'https://www.telerik.com/kendo-vue-ui/my-license/?utm_medium=product&utm_source=kendovue&utm_campaign=kendo-ui-vue-purchase-license-keys-warning'
 };

package/dist/es/store/reducer.d.ts

@@ -0,0 +1,14 @@
+import { StoreAction } from './store';
+/**
+ * @hidden
+ */
+declare const optionsReducer: (currentState: any, action: StoreAction) => object;
+/**
+ * @hidden
+ */
+declare const themeReducer: (currentState: any, action: StoreAction) => any;
+/**
+ * @hidden
+ */
+declare const observersReducer: (currentState: any, action: StoreAction) => any;
+export { optionsReducer, themeReducer, observersReducer };

package/dist/es/store/reducer.js

@@ -0,0 +1,100 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+/**
+ * @hidden
+ */
+var optionsReducer = function (currentState, action) {
+    if (action.gaugeCollectionIdxKey) {
+        return reducers.collectionConfigurationItem(currentState, action);
+    }
+    else if (action.gaugeKey) {
+        return reducers.configurationItem(currentState, action);
+    }
+    else {
+        return {};
+    }
+};
+/**
+ * @hidden
+ */
+var themeReducer = function (currentState, action) {
+    if (action.type) {
+        switch (action.type) {
+            case 'set':
+                return reducers.themeItem(currentState, action);
+            case 'push':
+                return Object.assign(currentState, action.payload);
+            default:
+                return currentState;
+        }
+    }
+    else {
+        return {};
+    }
+};
+/**
+ * @hidden
+ */
+var observersReducer = function (currentState, action) {
+    if (action.type) {
+        switch (action.type) {
+            case 'add':
+                return __spreadArrays(currentState, [action.payload]);
+            case 'remove':
+                return currentState.filter(function (element) { return element !== action.payload; });
+            default:
+                return currentState;
+        }
+    }
+    else {
+        return [];
+    }
+};
+/**
+ * @hidden
+ */
+var reducers = {
+    configurationItem: function (currentState, action) {
+        var _a;
+        return Object.assign(currentState, (_a = {},
+            _a[action.gaugeKey] = action.payload,
+            _a));
+    },
+    collectionConfigurationItem: function (currentState, action) {
+        var _a;
+        var inCollection = false;
+        var _b = action.gaugeCollectionIdxKey.split('_'), collectionName = _b[0], collectionIdx = _b[1];
+        var collection = currentState[collectionName].map(function (item, index) {
+            if (parseInt(collectionIdx, 10) === index) {
+                inCollection = true;
+                return action.payload;
+            }
+            return item;
+        });
+        if (inCollection === false) {
+            collection.splice(parseInt(collectionIdx, 10), 0, action.payload);
+        }
+        return Object.assign(currentState, (_a = {},
+            _a[collectionName] = collection,
+            _a));
+    },
+    themeItem: function (currentState, action) {
+        var store = {};
+        var nextStore = Object.assign(store, currentState);
+        var _a = action.payload, field = _a.field, value = _a.value;
+        var parts = field.split('.');
+        var key = parts.shift();
+        while (parts.length > 0) {
+            store = store[key] = store[key] || {};
+            key = parts.shift();
+        }
+        store[key] = value;
+        return nextStore;
+    }
+};
+export { optionsReducer, themeReducer, observersReducer };

package/dist/es/store/store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @hidden
+ */
+export declare const THROTTLE_MS: number;
+/**
+ * @hidden
+ */
+export interface StoreAction {
+    gaugeKey?: string;
+    gaugeCollectionIdxKey?: string;
+    type?: string;
+    payload: any;
+}
+/**
+ * @hidden
+ */
+export interface Store {
+    getState(): any;
+    dispatch(action: StoreAction | object): void;
+    subscribe(f: Function): Function;
+}
+/**
+ * @hidden
+ */
+declare const createStore: (reducer: any) => Store;
+export default createStore;

package/dist/es/store/store.js

@@ -0,0 +1,28 @@
+import { canUseDOM } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+export var THROTTLE_MS = 1000 / 60;
+/**
+ * @hidden
+ */
+var createStore = function (reducer) {
+    var state;
+    var timerId;
+    var listeners = [];
+    var getState = function () { return state; };
+    var dispatch = function (action) {
+        state = reducer(state, action);
+        if (canUseDOM) {
+            window.clearTimeout(timerId);
+            timerId = window.setTimeout(function () { return listeners.forEach(function (l) { return l(); }); }, THROTTLE_MS);
+        }
+    };
+    var subscribe = function (listener) {
+        listeners.push(listener);
+        return function () { return listeners = listeners.filter(function (l) { return l !== listener; }); };
+    };
+    dispatch({});
+    return { getState: getState, dispatch: dispatch, subscribe: subscribe };
+};
+export default createStore;