@handsontable/vue3 0.0.0-next-9ec04ce-20221121

package/HotColumn.vue.d.ts

@@ -0,0 +1,11 @@
+declare const HotColumn: import("vue").DefineComponent<import("./types").VueProps<import("./types").HotTableProps>, unknown, unknown, {}, {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("./types").VueProps<import("./types").HotTableProps>>>, {
+    [x: string]: any;
+}>;
+export default HotColumn;
+export { HotColumn };

package/HotTable.vue.d.ts

@@ -0,0 +1,30 @@
+import { VNode } from 'vue';
+import Handsontable from 'handsontable/base';
+import { HotTableProps } from './types';
+declare const HotTable: import("vue").DefineComponent<import("./types").VueProps<HotTableProps>, unknown, {
+    __hotInstance: Handsontable;
+    miscCache: {
+        currentSourceColumns: any;
+    };
+    columnSettings: HotTableProps[];
+    columnsCache: Map<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, HotTableProps>;
+    hotInstance: Handsontable;
+}, {}, {
+    /**
+     * Initialize Handsontable.
+     */
+    hotInit(): void;
+    matchHotMappersSize(): void;
+    /**
+     * Get settings for the columns provided in the `hot-column` components.
+     *
+     * @returns {HotTableProps[] | undefined}
+     */
+    getColumnSettings(): HotTableProps[] | void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("./types").VueProps<HotTableProps>>>, {
+    [x: string]: any;
+}>;
+export default HotTable;
+export { HotTable };

package/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) HANDSONCODE sp. z o. o.
+
+HANDSONTABLE is a software distributed by HANDSONCODE sp. z o. o., a Polish corporation based in
+Gdynia, Poland, at Aleja Zwycięstwa 96-98, registered by the District Court in Gdansk under number
+538651, EU tax ID number: PL5862294002, share capital: PLN 62,800.00.
+
+This software is protected by applicable copyright laws, including international treaties, and dual-
+licensed – depending on whether your use for commercial purposes, meaning intended for or
+resulting in commercial advantage or monetary compensation, or not.
+
+If your use is strictly personal or solely for evaluation purposes, meaning for the purposes of testing
+the suitability, performance, and usefulness of this software outside the production environment,
+you agree to be bound by the terms included in the "handsontable-non-commercial-license.pdf" file.
+
+Your use of this software for commercial purposes is subject to the terms included in an applicable
+license agreement.
+
+In any case, you must not make any such use of this software as to develop software which may be
+considered competitive with this software.
+
+UNLESS EXPRESSLY AGREED OTHERWISE, HANDSONCODE PROVIDES THIS SOFTWARE ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, AND IN NO EVENT AND UNDER NO
+LEGAL THEORY, SHALL HANDSONCODE BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
+INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
+USE OR INABILITY TO USE THIS SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+<div align="center">
+
+<a href="https://handsontable.com" rel="nofollow"><img src="https://raw.githubusercontent.com/handsontable/handsontable/develop/resources/handsontable-logo-blue.svg" alt="Handsontable - data grid for Vue 3" width="300"></a>
+
+# Data Grid for Vue 3<img src="https://raw.githubusercontent.com/handsontable/handsontable/develop/resources/icons/vue-icon.svg" width="22" height="22">
+
+Handsontable's wrapper for Vue 3 combines data grid features with spreadsheet-like UX. <br>
+It provides data binding, data validation, filtering, sorting, and CRUD operations.
+
+[![npm](https://img.shields.io/npm/dt/@handsontable/vue3.svg)](https://npmjs.com/package/@handsontable/vue3)
+[![npm](https://img.shields.io/npm/dm/@handsontable/vue3.svg)](https://npmjs.com/package/@handsontable/vue3)
+[![CI status](https://github.com/handsontable/handsontable/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/handsontable/handsontable/actions/workflows/test.yml?query=branch%3Amaster)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fhandsontable%2Fhandsontable.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fhandsontable%2Fhandsontable?ref=badge_shield)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=handsontable_handsontable&metric=alert_status)](https://sonarcloud.io/dashboard?id=handsontable_handsontable)
+
+---
+
+<a href="https://handsontable.com/demo"><img src="https://raw.githubusercontent.com/handsontable/handsontable/develop/resources/handsontable-github-preview.png" alt="Handsontable data grid for Vue 3" width="805"/></a>
+
+</div>
+
+## Features
+
+The most popular features of Handsontable for Vue 3:
+
+&nbsp;&nbsp;✓&nbsp; Multiple column sorting <br>
+&nbsp;&nbsp;✓&nbsp; Non-contiguous selection <br>
+&nbsp;&nbsp;✓&nbsp; Filtering data <br>
+&nbsp;&nbsp;✓&nbsp; Export to file <br>
+&nbsp;&nbsp;✓&nbsp; Validating data <br>
+&nbsp;&nbsp;✓&nbsp; Conditional formatting <br>
+&nbsp;&nbsp;✓&nbsp; Merging cells <br>
+&nbsp;&nbsp;✓&nbsp; Freezing rows/columns <br>
+&nbsp;&nbsp;✓&nbsp; Moving rows/columns <br>
+&nbsp;&nbsp;✓&nbsp; Resizing rows/columns <br>
+&nbsp;&nbsp;✓&nbsp; Hiding rows/columns <br>
+&nbsp;&nbsp;✓&nbsp; Context menu <br>
+&nbsp;&nbsp;✓&nbsp; Comments <br>
+
+## Documentation
+
+- [Developer guides](https://handsontable.com/docs/vue3-installation/)
+- [API Reference](https://handsontable.com/docs/api/core/)
+- [Changelog](https://handsontable.com/docs/release-notes/)
+- [Demo](https://handsontable.com/demo)
+
+<div id="installation"></div>
+
+## Get Started
+### Install with npm
+
+Run the following command in your terminal
+```
+npm install handsontable @handsontable/vue3
+```
+
+You can load it directly from [jsDelivr](https:jsdelivr.com/package/npm/@handsontable/vue3) as well.
+```html
+<script src="https://cdn.jsdelivr.net/npm/handsontable/dist/handsontable.full.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@handsontable/vue3/dist/vue-handsontable.min.js"></script>
+
+<link href="https://cdn.jsdelivr.net/npm/handsontable/dist/handsontable.full.min.css" rel="stylesheet">
+```
+
+The component will be available as `Handsontable.vue.HotTable`.
+
+### Usage
+
+Use this data grid as you would any other component in your application. [Options](https://handsontable.com/docs/api/options/) can be set as `HotTable` props.
+
+**Styles**
+```css
+@import '~handsontable/dist/handsontable.full.css';
+```
+
+**Vue 3 Component**
+```vue
+<template>
+  <hot-table :data="data" :rowHeaders="true" :colHeaders="true"></hot-table>
+</template>
+
+<script>
+  import { defineComponent } from 'vue';
+  import { HotTable } from '@handsontable/vue3';
+  import { registerAllModules } from 'handsontable/registry';
+
+  // register Handsontable's modules
+  registerAllModules();
+
+  export default defineComponent({
+    data() {
+      return {
+        data: [
+          ['', 'Ford', 'Volvo', 'Toyota', 'Honda'],
+          ['2016', 10, 11, 12, 13],
+          ['2017', 20, 11, 14, 13],
+          ['2018', 30, 15, 12, 13]
+        ],
+      };
+    },
+    components: {
+      HotTable,
+    }
+  });
+</script>
+
+<style src="handsontable/dist/handsontable.full.css"></style>
+```
+
+### [View live demo](https://handsontable.com/docs/vue3-simple-example/)
+
+## Support
+
+We provide support for developers working with commercial version via [contact form](https://handsontable.com/contact?category=technical_support)</a> or at support@handsontable.com.
+
+If you use a non-commercial version then please ask your tagged question on [StackOverflow](https://stackoverflow.com/questions/tagged/handsontable).
+
+## License
+
+Handsontable is a commercial software with two licenses available:
+
+- Free for non-commercial purposes such as teaching, academic research, and evaluation. [Read it here](https://github.com/handsontable/handsontable/blob/master/handsontable-non-commercial-license.pdf).
+- Commercial license with support and maintenance included. See [pricing plans](https://handsontable.com/pricing).
+
+## License key
+
+If you use Handsontable for Vue 3 in a project that supports your commercial activity, then you must purchase the license key at [handsontable.com](https://handsontable.com/pricing).
+
+If you use the free for non-commercial license of Handsontable, then pass the phrase `'non-commercial-and-evaluation'`, as described in [this documentation](https://handsontable.com/docs/license-key/).
+
+<br>
+<br>
+
+Proudly created and maintained by the [Handsontable Team](https://handsontable.com/team).

package/commonjs/HotColumn.vue.d.ts

@@ -0,0 +1,11 @@
+declare const HotColumn: import("vue").DefineComponent<import("./types").VueProps<import("./types").HotTableProps>, unknown, unknown, {}, {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("./types").VueProps<import("./types").HotTableProps>>>, {
+    [x: string]: any;
+}>;
+export default HotColumn;
+export { HotColumn };

package/commonjs/HotTable.vue.d.ts

@@ -0,0 +1,30 @@
+import { VNode } from 'vue';
+import Handsontable from 'handsontable/base';
+import { HotTableProps } from './types';
+declare const HotTable: import("vue").DefineComponent<import("./types").VueProps<HotTableProps>, unknown, {
+    __hotInstance: Handsontable;
+    miscCache: {
+        currentSourceColumns: any;
+    };
+    columnSettings: HotTableProps[];
+    columnsCache: Map<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, HotTableProps>;
+    hotInstance: Handsontable;
+}, {}, {
+    /**
+     * Initialize Handsontable.
+     */
+    hotInit(): void;
+    matchHotMappersSize(): void;
+    /**
+     * Get settings for the columns provided in the `hot-column` components.
+     *
+     * @returns {HotTableProps[] | undefined}
+     */
+    getColumnSettings(): HotTableProps[] | void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("./types").VueProps<HotTableProps>>>, {
+    [x: string]: any;
+}>;
+export default HotTable;
+export { HotTable };

package/commonjs/helpers.d.ts

@@ -0,0 +1,36 @@
+import Handsontable from 'handsontable/base';
+import { HotTableProps, VueProps } from './types';
+/**
+ * Message for the warning thrown if the Handsontable instance has been destroyed.
+ */
+export declare const HOT_DESTROYED_WARNING: string;
+/**
+ * Check if at specified `key` there is any value for `object`.
+ *
+ * @param {object} object Object to search value at specyfic key.
+ * @param {string} key String key to check.
+ * @returns {boolean}
+ */
+export declare function hasOwnProperty(object: unknown, key: string): boolean;
+/**
+ * Generate an object containing all the available Handsontable properties and plugin hooks.
+ *
+ * @param {string} source Source for the factory (either 'HotTable' or 'HotColumn').
+ * @returns {object}
+ */
+export declare function propFactory(source: 'HotTable' | 'HotColumn'): VueProps<HotTableProps>;
+/**
+ * Filter out all of the unassigned props, and return only the one passed to the component.
+ *
+ * @param {object} props Object containing all the possible props.
+ * @returns {object} Object containing only used props.
+ */
+export declare function filterPassedProps(props: any): VueProps<HotTableProps>;
+/**
+ * Prepare the settings object to be used as the settings for Handsontable, based on the props provided to the component.
+ *
+ * @param {HotTableProps} props The props passed to the component.
+ * @param {Handsontable.GridSettings} currentSettings The current Handsontable settings.
+ * @returns {Handsontable.GridSettings} An object containing the properties, ready to be used within Handsontable.
+ */
+export declare function prepareSettings(props: HotTableProps, currentSettings?: Handsontable.GridSettings): HotTableProps;

package/commonjs/index.d.ts

@@ -0,0 +1,3 @@
+import HotTable from './HotTable.vue';
+import HotColumn from './HotColumn.vue';
+export { HotTable as default, HotTable, HotColumn };

package/commonjs/types.d.ts

@@ -0,0 +1,9 @@
+import Handsontable from 'handsontable/base';
+export interface HotTableProps extends Handsontable.GridSettings {
+    id?: string;
+    settings?: Handsontable.GridSettings;
+    [additional: string]: any;
+}
+export declare type VueProps<T> = {
+    [P in keyof T]: any;
+};

package/commonjs/vue-handsontable.js

@@ -0,0 +1,343 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var Handsontable = require('handsontable/base');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Handsontable__default = /*#__PURE__*/_interopDefaultLegacy(Handsontable);
+
+var unassignedPropSymbol = Symbol('unassigned');
+/**
+ * Message for the warning thrown if the Handsontable instance has been destroyed.
+ */
+var HOT_DESTROYED_WARNING = 'The Handsontable instance bound to this component was destroyed and cannot be' + ' used properly.';
+/**
+ * Check if at specified `key` there is any value for `object`.
+ *
+ * @param {object} object Object to search value at specyfic key.
+ * @param {string} key String key to check.
+ * @returns {boolean}
+ */
+function hasOwnProperty(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+/**
+ * Generate an object containing all the available Handsontable properties and plugin hooks.
+ *
+ * @param {string} source Source for the factory (either 'HotTable' or 'HotColumn').
+ * @returns {object}
+ */
+function propFactory(source) {
+  var registeredHooks = Handsontable__default["default"].hooks.getRegistered();
+  var propSchema = {};
+  Object.assign(propSchema, Handsontable__default["default"].DefaultSettings);
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+  for (var prop in propSchema) {
+    propSchema[prop] = {
+      "default": unassignedPropSymbol
+    };
+  }
+  for (var i = 0; i < registeredHooks.length; i++) {
+    propSchema[registeredHooks[i]] = {
+      "default": unassignedPropSymbol
+    };
+  }
+  propSchema.settings = {
+    "default": unassignedPropSymbol
+  };
+  if (source === 'HotTable') {
+    propSchema.id = {
+      type: String,
+      "default": "hot-".concat(Math.random().toString(36).substring(5))
+    };
+  }
+  return propSchema;
+}
+/**
+ * Filter out all of the unassigned props, and return only the one passed to the component.
+ *
+ * @param {object} props Object containing all the possible props.
+ * @returns {object} Object containing only used props.
+ */
+function filterPassedProps(props) {
+  var filteredProps = {};
+  var columnSettingsProp = props.settings;
+  if (columnSettingsProp !== unassignedPropSymbol) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (var propName in columnSettingsProp) {
+      if (hasOwnProperty(columnSettingsProp, propName) && columnSettingsProp[propName] !== unassignedPropSymbol) {
+        filteredProps[propName] = columnSettingsProp[propName];
+      }
+    }
+  }
+  // eslint-disable-next-line no-restricted-syntax
+  for (var _propName in props) {
+    if (hasOwnProperty(props, _propName) && _propName !== 'settings' && props[_propName] !== unassignedPropSymbol) {
+      filteredProps[_propName] = props[_propName];
+    }
+  }
+  return filteredProps;
+}
+/**
+ * Prepare the settings object to be used as the settings for Handsontable, based on the props provided to the component.
+ *
+ * @param {HotTableProps} props The props passed to the component.
+ * @param {Handsontable.GridSettings} currentSettings The current Handsontable settings.
+ * @returns {Handsontable.GridSettings} An object containing the properties, ready to be used within Handsontable.
+ */
+function prepareSettings(props, currentSettings) {
+  var assignedProps = filterPassedProps(props);
+  var hotSettingsInProps = props.settings ? props.settings : assignedProps;
+  var additionalHotSettingsInProps = props.settings ? assignedProps : null;
+  var newSettings = {};
+  // eslint-disable-next-line no-restricted-syntax
+  for (var key in hotSettingsInProps) {
+    if (hasOwnProperty(hotSettingsInProps, key) && hotSettingsInProps[key] !== void 0 && (currentSettings && key !== 'data' ? !simpleEqual(currentSettings[key], hotSettingsInProps[key]) : true)) {
+      newSettings[key] = hotSettingsInProps[key];
+    }
+  }
+  // eslint-disable-next-line no-restricted-syntax
+  for (var _key in additionalHotSettingsInProps) {
+    if (hasOwnProperty(additionalHotSettingsInProps, _key) && _key !== 'id' && _key !== 'settings' && additionalHotSettingsInProps[_key] !== void 0 && (currentSettings && _key !== 'data' ? !simpleEqual(currentSettings[_key], additionalHotSettingsInProps[_key]) : true)) {
+      newSettings[_key] = additionalHotSettingsInProps[_key];
+    }
+  }
+  return newSettings;
+}
+/**
+ * Compare two objects using `JSON.stringify`.
+ * *Note: * As it's using the stringify function to compare objects, the property order in both objects is
+ * important. It will return `false` for the same objects, if they're defined in a different order.
+ *
+ * @param {object} objectA First object to compare.
+ * @param {object} objectB Second object to compare.
+ * @returns {boolean} `true` if they're the same, `false` otherwise.
+ */
+function simpleEqual(objectA, objectB) {
+  return JSON.stringify(objectA) === JSON.stringify(objectB);
+}
+
+var version="0.0.0-next-9ec04ce-20221121";
+
+var HotTable = vue.defineComponent({
+  name: 'HotTable',
+  props: propFactory('HotTable'),
+  provide: function provide() {
+    return {
+      columnsCache: this.columnsCache
+    };
+  },
+  watch: {
+    $props: {
+      handler: function handler(props) {
+        var settings = prepareSettings(props, this.hotInstance ? this.hotInstance.getSettings() : void 0);
+        if (!this.hotInstance || settings === void 0) {
+          return;
+        }
+        if (settings.data) {
+          if (this.hotInstance.isColumnModificationAllowed() || !this.hotInstance.isColumnModificationAllowed() && this.hotInstance.countSourceCols() === this.miscCache.currentSourceColumns) {
+            // If the dataset dimensions change, update the index mappers.
+            this.matchHotMappersSize();
+            // Data is automatically synchronized by reference.
+            delete settings.data;
+          }
+        }
+        // If there are another options changed, update the HOT settings, render the table otherwise.
+        if (Object.keys(settings).length) {
+          this.hotInstance.updateSettings(settings);
+        } else {
+          this.hotInstance.render();
+        }
+        this.miscCache.currentSourceColumns = this.hotInstance.countSourceCols();
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  data: function data() {
+    return {
+      /* eslint-disable vue/no-reserved-keys */
+      __hotInstance: null,
+      /* eslint-enable vue/no-reserved-keys */
+      miscCache: {
+        currentSourceColumns: null
+      },
+      columnSettings: null,
+      columnsCache: new Map(),
+      get hotInstance() {
+        if (!this.__hotInstance || this.__hotInstance && !this.__hotInstance.isDestroyed) {
+          // Will return the Handsontable instance or `null` if it's not yet been created.
+          return this.__hotInstance;
+        } else {
+          /* eslint-disable-next-line no-console */
+          console.warn(HOT_DESTROYED_WARNING);
+          return null;
+        }
+      },
+      set hotInstance(hotInstance) {
+        this.__hotInstance = hotInstance;
+      }
+    };
+  },
+  methods: {
+    /**
+     * Initialize Handsontable.
+     */
+    hotInit: function hotInit() {
+      var newSettings = prepareSettings(this.$props);
+      newSettings.columns = this.columnSettings ? this.columnSettings : newSettings.columns;
+      this.hotInstance = vue.markRaw(new Handsontable__default["default"].Core(this.$el, newSettings));
+      this.hotInstance.init();
+      this.miscCache.currentSourceColumns = this.hotInstance.countSourceCols();
+    },
+    matchHotMappersSize: function matchHotMappersSize() {
+      var _this = this;
+      if (!this.hotInstance) {
+        return;
+      }
+      var data = this.hotInstance.getSourceData();
+      var rowsToRemove = [];
+      var columnsToRemove = [];
+      var indexMapperRowCount = this.hotInstance.rowIndexMapper.getNumberOfIndexes();
+      var isColumnModificationAllowed = this.hotInstance.isColumnModificationAllowed();
+      var indexMapperColumnCount = 0;
+      if (data && data.length !== indexMapperRowCount) {
+        if (data.length < indexMapperRowCount) {
+          for (var r = data.length; r < indexMapperRowCount; r++) {
+            rowsToRemove.push(r);
+          }
+        }
+      }
+      if (isColumnModificationAllowed) {
+        var _data$;
+        indexMapperColumnCount = this.hotInstance.columnIndexMapper.getNumberOfIndexes();
+        if (data && data[0] && ((_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$.length) !== indexMapperColumnCount) {
+          if (data[0].length < indexMapperColumnCount) {
+            for (var c = data[0].length; c < indexMapperColumnCount; c++) {
+              columnsToRemove.push(c);
+            }
+          }
+        }
+      }
+      this.hotInstance.batch(function () {
+        if (rowsToRemove.length > 0) {
+          _this.hotInstance.rowIndexMapper.removeIndexes(rowsToRemove);
+        } else {
+          _this.hotInstance.rowIndexMapper.insertIndexes(indexMapperRowCount - 1, data.length - indexMapperRowCount);
+        }
+        if (isColumnModificationAllowed && data.length !== 0) {
+          if (columnsToRemove.length > 0) {
+            _this.hotInstance.columnIndexMapper.removeIndexes(columnsToRemove);
+          } else {
+            _this.hotInstance.columnIndexMapper.insertIndexes(indexMapperColumnCount - 1, data[0].length - indexMapperColumnCount);
+          }
+        }
+      });
+    },
+    /**
+     * Get settings for the columns provided in the `hot-column` components.
+     *
+     * @returns {HotTableProps[] | undefined}
+     */
+    getColumnSettings: function getColumnSettings() {
+      var columnSettings = Array.from(this.columnsCache.values());
+      return columnSettings.length ? columnSettings : void 0;
+    }
+  },
+  mounted: function mounted() {
+    this.columnSettings = this.getColumnSettings();
+    this.hotInit();
+  },
+  beforeUnmount: function beforeUnmount() {
+    if (this.hotInstance) {
+      this.hotInstance.destroy();
+    }
+  },
+  version: version
+});
+
+var _hoisted_1 = ["id"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("div", {
+    id: _ctx.id
+  }, [vue.renderSlot(_ctx.$slots, "default")], 8 /* PROPS */, _hoisted_1);
+}
+
+HotTable.render = render;
+HotTable.__file = "src/HotTable.vue";
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+var HotColumn = vue.defineComponent({
+  name: 'HotColumn',
+  props: propFactory('HotColumn'),
+  inject: ['columnsCache'],
+  methods: {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings: function createColumnSettings() {
+      var assignedProps = filterPassedProps(this.$props);
+      var columnSettings = _objectSpread2({}, assignedProps);
+      if (assignedProps.renderer) {
+        columnSettings.renderer = assignedProps.renderer;
+      }
+      if (assignedProps.editor) {
+        columnSettings.editor = assignedProps.editor;
+      }
+      this.columnsCache.set(this, columnSettings);
+    }
+  },
+  mounted: function mounted() {
+    this.createColumnSettings();
+  },
+  unmounted: function unmounted() {
+    this.columnsCache["delete"](this);
+  },
+  render: function render() {
+    return null;
+  }
+});
+
+HotColumn.__file = "src/HotColumn.vue";
+
+exports.HotColumn = HotColumn;
+exports.HotTable = HotTable;
+exports["default"] = HotTable;

package/dist/HotColumn.vue.d.ts

@@ -0,0 +1,11 @@
+declare const HotColumn: import("vue").DefineComponent<import("./types").VueProps<import("./types").HotTableProps>, unknown, unknown, {}, {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("./types").VueProps<import("./types").HotTableProps>>>, {
+    [x: string]: any;
+}>;
+export default HotColumn;
+export { HotColumn };