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

package/dist/esm/Chart.d.ts

@@ -0,0 +1,52 @@
+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 { ChartProps } from './ChartProps';
+import { BaseChartState } from './BaseChart';
+/**
+ * Represents the [Kendo UI for Vue Chart component]({% slug overview_chart_charts %}).
+ *
+ * ```
+ */
+/**
+ * @hidden
+ */
+interface ChartState {
+    baseChartRef: any;
+    baseChart: BaseChartState | null;
+}
+/**
+ * @hidden
+ */
+interface ChartData {
+}
+/**
+ * @hidden
+ */
+export interface ChartMethods {
+    [key: string]: any;
+    chartInstance: () => any;
+}
+/**
+ * @hidden
+ */
+export interface ChartComputed {
+    [key: string]: any;
+    wrapperClass: object;
+}
+/**
+ * @hidden
+ */
+export interface ChartAll extends ChartMethods, ChartState, ChartData, ChartComputed, Vue2type {
+}
+/**
+ * @hidden
+ */
+declare const ChartVue2: ComponentOptions<Vue2type, DefaultData<ChartData>, DefaultMethods<ChartAll>, ChartComputed, RecordPropsDefinition<ChartProps>>;
+/**
+ * @hidden
+ */
+declare const Chart: DefineComponent<ChartProps, any, ChartData, ChartComputed, ChartMethods, {}, {}, {}, string, ChartProps, ChartProps, {}>;
+export { Chart, ChartVue2 };

package/dist/esm/Chart.js

@@ -0,0 +1,194 @@
+// @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 { BaseChart } from './BaseChart.js';
+import { DonutCenter } from './DonutCenter.js';
+import { Chart as KendoChart } from '@progress/kendo-charts';
+import { classNames, getDefaultSlots, getListeners, getRef, setRef, templateRendering } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var ChartVue2 = {
+  name: 'KendoChart',
+  props: {
+    donutCenterRender: [String, Function, Object],
+    dir: String,
+    renderAs: {
+      type: String,
+      default: undefined,
+      validator: function validator(value) {
+        return ['svg', 'canvas'].includes(value);
+      }
+    },
+    pannable: {
+      type: [Boolean, Object],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    zoomable: {
+      type: [Boolean, Object],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    seriesColors: {
+      type: Array,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    transitions: {
+      type: Boolean,
+      default: true
+    },
+    paneDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    panes: {
+      type: Array,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    seriesDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    axisDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    }
+  },
+  updated: function updated() {
+    this.baseChart = getRef(this, 'baseChart');
+  },
+  mounted: function mounted() {
+    this.baseChart = getRef(this, 'baseChart');
+  },
+  methods: {
+    chartInstance: function chartInstance() {
+      if (this.baseChart !== null) {
+        return this.baseChart.chartInstance;
+      }
+
+      return null;
+    },
+    surface: function surface() {
+      if (this.baseChart !== null) {
+        return this.baseChart.surface;
+      }
+
+      return null;
+    },
+    element: function element() {
+      if (this.baseChart !== null) {
+        return this.baseChart.element;
+      }
+
+      return null;
+    },
+    getTarget: function getTarget() {
+      return this;
+    },
+    handleBaseChartEvents: function handleBaseChartEvents(name, options) {
+      this.$emit(name, options);
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    var defaultSlots = getDefaultSlots(this);
+    var _a = this.$props,
+        donutCenterRender = _a.donutCenterRender,
+        dir = _a.dir,
+        renderAs = _a.renderAs,
+        pannable = _a.pannable,
+        zoomable = _a.zoomable,
+        seriesColors = _a.seriesColors,
+        transitions = _a.transitions,
+        paneDefaults = _a.paneDefaults,
+        panes = _a.panes,
+        seriesDefaults = _a.seriesDefaults,
+        axisDefaults = _a.axisDefaults;
+    var centerRender = donutCenterRender ? templateRendering.call(this, donutCenterRender, getListeners.call(this)) : null;
+    return (// @ts-ignore  function children
+      h(BaseChart, {
+        dir: dir,
+        attrs: this.v3 ? undefined : {
+          dir: dir,
+          renderAs: renderAs,
+          pannable: pannable,
+          zoomable: zoomable,
+          seriesColors: seriesColors,
+          transitions: transitions,
+          paneDefaults: paneDefaults,
+          panes: panes,
+          seriesDefaults: seriesDefaults,
+          axisDefaults: axisDefaults,
+          chartConstructor: KendoChart,
+          getTarget: this.getTarget,
+          wrapper: "div",
+          allListeners: getListeners.call(this)
+        },
+        renderAs: renderAs,
+        pannable: pannable,
+        zoomable: zoomable,
+        seriesColors: seriesColors,
+        transitions: transitions,
+        paneDefaults: paneDefaults,
+        panes: panes,
+        seriesDefaults: seriesDefaults,
+        axisDefaults: axisDefaults,
+        ref: setRef(this, 'baseChart'),
+        chartConstructor: KendoChart,
+        getTarget: this.getTarget,
+        wrapper: "div",
+        "class": classNames('k-chart k-widget'),
+        onBasechartevent: this.handleBaseChartEvents,
+        on: this.v3 ? undefined : {
+          "basechartevent": this.handleBaseChartEvents
+        },
+        allListeners: getListeners.call(this)
+      }, this.v3 ? function () {
+        return [defaultSlots, // @ts-ignore
+        h(DonutCenter, {
+          render: centerRender,
+          attrs: _this.v3 ? undefined : {
+            render: centerRender
+          }
+        })];
+      } : [defaultSlots, h(DonutCenter, {
+        render: centerRender,
+        attrs: _this.v3 ? undefined : {
+          render: centerRender
+        }
+      })])
+    );
+  }
+};
+/**
+ * @hidden
+ */
+
+var Chart = ChartVue2;
+export { Chart, ChartVue2 };

package/dist/esm/ChartContext.d.ts

@@ -0,0 +1,14 @@
+import { Store } from './store/store';
+import { InstanceObserver } from '@progress/kendo-charts';
+/**
+ * @hidden
+ */
+export interface ChartContextType {
+    optionsState: Store;
+    observersState: Store;
+    childrenObserver: InstanceObserver;
+}
+/**
+ * @hidden
+ */
+export declare const ChartContext: any;

package/dist/esm/ChartContext.js

@@ -0,0 +1,5 @@
+/**
+ * @hidden
+ */
+export var ChartContext = null;
+// ChartContext.displayName = 'ChartContext';

package/dist/esm/ChartProps.d.ts

@@ -0,0 +1,10 @@
+import { BaseChartProps } from './BaseChartProps';
+/**
+ * Represents the props of the Kendo UI for Vue Chart component.
+ */
+export interface ChartProps extends BaseChartProps {
+    /**
+     * When set, the prop is used to render the Donut Center template.
+     */
+    donutCenterRender?: string | Function | object;
+}

package/dist/esm/ChartProps.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/DonutCenter.d.ts

@@ -0,0 +1,60 @@
+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 { InstanceObserver } from '@progress/kendo-charts';
+/**
+ * @hidden
+ */
+export interface DonutCenterStyle {
+    height: string;
+    left: string;
+    top: string;
+    width: string;
+}
+/**
+ * @hidden
+ */
+export interface DonutCenterProps {
+    render?: any;
+}
+/**
+ * @hidden
+ */
+export interface DonutCenterState {
+    chartObserver: InstanceObserver;
+}
+/**
+ * @hidden
+ */
+interface DonutCenterData {
+    donutCenterStyles: DonutCenterStyle | null;
+}
+/**
+ * @hidden
+ */
+export interface DonutCenterMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface DonutCenterComputed {
+    [key: string]: any;
+    wrapperClass: object;
+}
+/**
+ * @hidden
+ */
+export interface DonutCenterAll extends DonutCenterMethods, DonutCenterState, DonutCenterData, DonutCenterComputed, Vue2type {
+}
+/**
+ * @hidden
+ */
+declare const DonutCenterVue2: ComponentOptions<Vue2type, DefaultData<DonutCenterData>, DefaultMethods<DonutCenterAll>, DonutCenterComputed, RecordPropsDefinition<DonutCenterProps>>;
+/**
+ * @hidden
+ */
+declare const DonutCenter: DefineComponent<DonutCenterProps, any, DonutCenterData, DonutCenterComputed, DonutCenterMethods, {}, {}, {}, string, DonutCenterProps, DonutCenterProps, {}>;
+export { DonutCenter, DonutCenterVue2 };

package/dist/esm/DonutCenter.js

@@ -0,0 +1,100 @@
+// @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 { InstanceObserver } from '@progress/kendo-charts';
+import { getTemplate } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var DonutCenterVue2 = {
+  name: 'KendoDonutCenter',
+  props: {
+    render: [String, Function, Object]
+  },
+  data: function data() {
+    return {
+      donutCenterStyles: null
+    };
+  },
+  inject: {
+    optionsState: {
+      default: {}
+    },
+    dispatchOptions: {
+      default: null
+    },
+    dispatchObservers: {
+      default: null
+    },
+    childrenObserver: {
+      default: null
+    }
+  },
+  created: function created() {
+    this.dispatchObservers({
+      type: 'add',
+      payload: new InstanceObserver(this, {
+        render: 'onRender'
+      })
+    });
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var render = this.$props.render;
+    var renderer = h("span");
+    var centerElement = getTemplate.call(this, {
+      h: h,
+      template: render,
+      defaultRendering: null
+    });
+
+    if (render && this.donutCenterStyles) {
+      renderer = h("div", {
+        "class": "k-chart-donut-center",
+        style: this.donutCenterStyles
+      }, [centerElement]);
+    }
+
+    return renderer;
+  },
+  methods: {
+    onRender: function onRender(event) {
+      var series = this.optionsState.series;
+      var firstSeries = Array.isArray(series) ? series[0] : null;
+      var charts = event.sender._plotArea.charts;
+
+      if (!firstSeries || firstSeries.type !== 'donut' || charts[0].points.length === 0) {
+        return;
+      }
+
+      var sector = charts[0].points[0].sector;
+      var radius = sector.innerRadius;
+      var top = sector.center.y - radius;
+      var left = sector.center.x - radius;
+      var size = radius * 2;
+      this.donutCenterStyles = {
+        height: size + 'px',
+        left: left + 'px',
+        top: top + 'px',
+        width: size + 'px'
+      };
+    }
+  }
+};
+/**
+ * @hidden
+ */
+
+var DonutCenter = DonutCenterVue2;
+export { DonutCenter, DonutCenterVue2 };

package/dist/esm/Sparkline.d.ts

@@ -0,0 +1,47 @@
+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 { SparklineProps } from './SparklineProps';
+import { BaseChartState } from './BaseChart';
+/**
+ * @hidden
+ */
+interface SparklineState {
+    baseChartRef: any;
+    baseChart: BaseChartState | null;
+}
+/**
+ * @hidden
+ */
+interface SparklineData {
+}
+/**
+ * @hidden
+ */
+export interface SparklineMethods {
+    [key: string]: any;
+    chartInstance: () => any;
+}
+/**
+ * @hidden
+ */
+export interface SparklineComputed {
+    [key: string]: any;
+    wrapperClass: object;
+}
+/**
+ * @hidden
+ */
+export interface SparklineAll extends SparklineMethods, SparklineState, SparklineData, SparklineComputed, Vue2type {
+}
+/**
+ * @hidden
+ */
+declare const SparklineVue2: ComponentOptions<Vue2type, DefaultData<SparklineData>, DefaultMethods<SparklineAll>, SparklineComputed, RecordPropsDefinition<SparklineProps>>;
+/**
+ * @hidden
+ */
+declare const Sparkline: DefineComponent<SparklineProps, any, SparklineData, SparklineComputed, SparklineMethods, {}, {}, {}, string, SparklineProps, SparklineProps, {}>;
+export { Sparkline, SparklineVue2 };

package/dist/esm/Sparkline.js

@@ -0,0 +1,197 @@
+// @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 { BaseChart } from './BaseChart.js';
+import { Sparkline as KendoSparkline } from '@progress/kendo-charts';
+import { classNames, getDefaultSlots, getRef, setRef } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var SparklineVue2 = {
+  name: 'KendoSparkline',
+  props: {
+    dataItems: {
+      type: Array,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    type: String,
+    dir: String,
+    renderAs: {
+      type: String,
+      default: undefined,
+      validator: function validator(value) {
+        return ['svg', 'canvas'].includes(value);
+      }
+    },
+    pannable: {
+      type: [Boolean, Object],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    zoomable: {
+      type: [Boolean, Object],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    seriesColors: {
+      type: Array,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    transitions: {
+      type: Boolean,
+      default: true
+    },
+    paneDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    panes: {
+      type: Array,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    seriesDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    axisDefaults: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    }
+  },
+  updated: function updated() {
+    this.baseChart = getRef(this, 'baseChart');
+  },
+  mounted: function mounted() {
+    this.baseChart = getRef(this, 'baseChart');
+  },
+  methods: {
+    chartInstance: function chartInstance() {
+      if (this.baseChart !== null) {
+        return this.baseChart.chartInstance;
+      }
+
+      return null;
+    },
+    surface: function surface() {
+      if (this.baseChart !== null) {
+        return this.baseChart.surface;
+      }
+
+      return null;
+    },
+    element: function element() {
+      if (this.baseChart !== null) {
+        return this.baseChart.element;
+      }
+
+      return null;
+    },
+    getTarget: function getTarget() {
+      return this;
+    },
+    deriveOptionsFromParent: function deriveOptionsFromParent(options) {
+      var _a = this.$props,
+          type = _a.type,
+          dataItems = _a.dataItems;
+      var sparklineOptions = Object.assign({}, options, {
+        type: type,
+        data: dataItems
+      });
+      return KendoSparkline.normalizeOptions(sparklineOptions);
+    },
+    handleBaseChartEvents: function handleBaseChartEvents(name, options) {
+      this.$emit(name, options);
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var defaultSlots = getDefaultSlots(this);
+    var _a = this.$props,
+        dataItems = _a.dataItems,
+        dir = _a.dir,
+        renderAs = _a.renderAs,
+        pannable = _a.pannable,
+        zoomable = _a.zoomable,
+        seriesColors = _a.seriesColors,
+        transitions = _a.transitions,
+        paneDefaults = _a.paneDefaults,
+        panes = _a.panes,
+        seriesDefaults = _a.seriesDefaults,
+        axisDefaults = _a.axisDefaults;
+    return (// @ts-ignore  function children
+      h(BaseChart, {
+        dataItems: dataItems,
+        attrs: this.v3 ? undefined : {
+          dataItems: dataItems,
+          dir: dir,
+          renderAs: renderAs,
+          pannable: pannable,
+          zoomable: zoomable,
+          seriesColors: seriesColors,
+          transitions: transitions,
+          paneDefaults: paneDefaults,
+          panes: panes,
+          seriesDefaults: seriesDefaults,
+          axisDefaults: axisDefaults,
+          chartConstructor: KendoSparkline,
+          getTarget: this.getTarget,
+          wrapper: "span",
+          deriveOptionsFromParent: this.deriveOptionsFromParent
+        },
+        dir: dir,
+        renderAs: renderAs,
+        pannable: pannable,
+        zoomable: zoomable,
+        seriesColors: seriesColors,
+        transitions: transitions,
+        paneDefaults: paneDefaults,
+        panes: panes,
+        seriesDefaults: seriesDefaults,
+        axisDefaults: axisDefaults,
+        ref: setRef(this, 'baseChart'),
+        chartConstructor: KendoSparkline,
+        getTarget: this.getTarget,
+        wrapper: "span",
+        deriveOptionsFromParent: this.deriveOptionsFromParent,
+        "class": classNames('k-sparkline k-widget'),
+        onBasechartevent: this.handleBaseChartEvents,
+        on: this.v3 ? undefined : {
+          "basechartevent": this.handleBaseChartEvents
+        }
+      }, this.v3 ? function () {
+        return [defaultSlots];
+      } : [defaultSlots])
+    );
+  }
+};
+/**
+ * @hidden
+ */
+
+var Sparkline = SparklineVue2;
+export { Sparkline, SparklineVue2 };

package/dist/esm/SparklineProps.d.ts

@@ -0,0 +1,14 @@
+import { BaseChartProps } from './BaseChartProps';
+/**
+ * Represents the props of the Kendo UI for Vue Native Sparkline component.
+ */
+export interface SparklineProps extends BaseChartProps {
+    /**
+     * The data for the default Sparkline series. Discarded if series are supplied.
+     */
+    dataItems?: any;
+    /**
+     * The data for the default Sparkline series. Discarded if series are supplied.
+     */
+    type?: string;
+}

package/dist/esm/SparklineProps.js

@@ -0,0 +1 @@
+export {};