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

package/dist/npm/BaseGaugeProps.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @hidden
+ */
+export interface BaseGaugePrivateProps {
+    /**
+     * @hidden
+     */
+    deriveOptionsFromParent?: (options: any) => any;
+    /**
+     * @hidden
+     */
+    gaugeConstructor?: object;
+    /**
+     * @hidden
+     */
+    getTarget?: () => any;
+}
+/**
+ * @hidden
+ */
+export interface BaseGaugeProps extends BaseGaugePrivateProps {
+    /**
+     * Represents the `dir` HTML attribute.
+     */
+    dir?: string;
+    value?: number;
+    color?: any;
+    colors?: any[];
+    opacity?: any;
+    /**
+     * Sets the preferred rendering engine. If not supported by the browser, the Gauge switches to the first available mode.
+     *
+     * The supported values are:
+     * - `"svg"`—If available, renders the component as an inline `.svg` file.
+     * - `"canvas"`—If available, renders the component as a `canvas` element.
+     */
+    renderAs?: 'svg' | 'canvas' | string;
+    /**
+     * If set to `true`, the Gauge plays animations when it displays the series. By default, animations are enabled.
+     */
+    transitions?: boolean;
+}

package/dist/npm/BaseGaugeProps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+}); // tslint:enable:max-line-length

package/dist/npm/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/npm/CircularGauge.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var __assign = undefined && undefined.__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);
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CircularGaugeVue3 = exports.CircularGauge = void 0; // @ts-ignore
+
+var Vue = require("vue");
+
+var allVue = Vue;
+var gh = allVue.h;
+
+var ArcGauge_1 = require("./ArcGauge");
+
+var kendo_charts_1 = require("@progress/kendo-charts"); // tslint:enable:max-line-length
+
+
+var CircularGauge = __assign(__assign({}, ArcGauge_1.ArcGauge), {
+  name: 'KendoCircularGauge',
+  created: function created() {
+    this.gaugeType = kendo_charts_1.CircularGauge;
+    this.arcCenterStyles = {};
+  }
+});
+
+exports.CircularGauge = CircularGauge;
+var CircularGaugeVue3 = CircularGauge;
+exports.CircularGaugeVue3 = CircularGaugeVue3;

package/dist/npm/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/npm/CircularGaugeProps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/npm/GaugeContext.d.ts

@@ -0,0 +1 @@
+

package/dist/npm/GaugeContext.js

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

package/dist/npm/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/npm/LinearGauge.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LinearGaugeVue3 = exports.LinearGauge = void 0; // @ts-ignore
+
+var Vue = require("vue");
+
+var allVue = Vue;
+var gh = allVue.h;
+
+var BaseGauge_1 = require("./BaseGauge");
+
+var kendo_charts_1 = require("@progress/kendo-charts");
+
+var kendo_drawing_1 = require("@progress/kendo-drawing");
+
+var kendo_vue_common_1 = require("@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 = kendo_vue_common_1.getDefaultSlots(this);
+    return (// @ts-ignore  function children
+      h(BaseGauge_1.BaseGauge, {
+        deriveOptionsFromParent: this.deriveOptionsFromParent,
+        attrs: this.v3 ? undefined : {
+          deriveOptionsFromParent: this.deriveOptionsFromParent,
+          gaugeConstructor: kendo_charts_1.LinearGauge,
+          getTarget: this.getTarget
+        },
+        ref: this.v3 ? function (el) {
+          _this.baseGaugeRef = el;
+        } : 'baseGauge',
+        gaugeConstructor: kendo_charts_1.LinearGauge,
+        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 kendo_drawing_1.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
+      });
+    }
+  }
+};
+exports.LinearGauge = LinearGauge;
+var LinearGaugeVue3 = LinearGauge;
+exports.LinearGaugeVue3 = LinearGaugeVue3;

package/dist/npm/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/npm/LinearGaugeProps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/npm/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/npm/RadialGauge.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RadialGaugeVue3 = exports.RadialGauge = void 0; // @ts-ignore
+
+var Vue = require("vue");
+
+var allVue = Vue;
+var gh = allVue.h;
+
+var BaseGauge_1 = require("./BaseGauge");
+
+var kendo_charts_1 = require("@progress/kendo-charts");
+
+var kendo_drawing_1 = require("@progress/kendo-drawing");
+
+var kendo_vue_common_1 = require("@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 = kendo_vue_common_1.getDefaultSlots(this);
+    var className = this.$props.className;
+    return (// @ts-ignore  function children
+      h(BaseGauge_1.BaseGauge, {
+        deriveOptionsFromParent: this.deriveOptionsFromParent,
+        attrs: this.v3 ? undefined : {
+          deriveOptionsFromParent: this.deriveOptionsFromParent,
+          gaugeConstructor: kendo_charts_1.RadialGauge,
+          getTarget: this.getTarget
+        },
+        ref: this.v3 ? function (el) {
+          _this.baseGaugeRef = el;
+        } : 'baseGauge',
+        gaugeConstructor: kendo_charts_1.RadialGauge,
+        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 kendo_drawing_1.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
+      });
+    }
+  }
+};
+exports.RadialGauge = RadialGauge;
+var RadialGaugeVue3 = RadialGauge;
+exports.RadialGaugeVue3 = RadialGaugeVue3;

package/dist/npm/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/npm/RadialGaugeProps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/npm/additionalTypes.ts

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

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

@@ -0,0 +1 @@
+

package/dist/npm/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/npm/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/npm/main.js

@@ -1,10 +1,23 @@
 "use strict";
-// 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';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadialGauge = exports.LinearGauge = exports.CircularGauge = exports.ArcGauge = void 0;
+var ArcGauge_1 = require("./ArcGauge");
+Object.defineProperty(exports, "ArcGauge", { enumerable: true, get: function () { return ArcGauge_1.ArcGauge; } });
+var CircularGauge_1 = require("./CircularGauge");
+Object.defineProperty(exports, "CircularGauge", { enumerable: true, get: function () { return CircularGauge_1.CircularGauge; } });
+var LinearGauge_1 = require("./LinearGauge");
+Object.defineProperty(exports, "LinearGauge", { enumerable: true, get: function () { return LinearGauge_1.LinearGauge; } });
+var RadialGauge_1 = require("./RadialGauge");
+Object.defineProperty(exports, "RadialGauge", { enumerable: true, get: function () { return RadialGauge_1.RadialGauge; } });
+// export * from './common/gauges';
+__exportStar(require("./types"), exports);

package/dist/npm/package-metadata.js

@@ -8,7 +8,7 @@ exports.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/npm/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 };