{"version":3,"file":"vue-handsontable.js","sources":["../src/helpers.ts","../src/lib/lru/lru.js","../src/HotTable.vue","../node_modules/vue-runtime-helpers/dist/normalize-component.js","../src/HotColumn.vue","../node_modules/vue-class-component/dist/vue-class-component.esm.js","../src/BaseEditorComponent.vue"],"sourcesContent":["import Vue, { VNode } from 'vue';\nimport Handsontable from 'handsontable';\nimport { HotTableProps, VueProps, EditorComponent } from './types';\n\nconst unassignedPropSymbol = Symbol('unassigned');\nlet bulkComponentContainer = null;\n\n/**\n * Rewrite the settings object passed to the watchers to be a clean array/object prepared to use within Handsontable config.\n *\n * @param {*} observerSettings Watcher object containing the changed data.\n * @returns {Object|Array}\n */\nexport function rewriteSettings(observerSettings): any[] | object {\n  const settingsType = Object.prototype.toString.call(observerSettings);\n  let settings: any[] | object | null = null;\n  let type: { array?: boolean, object?: boolean } = {};\n\n  if (settingsType === '[object Array]') {\n    settings = [];\n    type.array = true;\n\n  } else if (settingsType === '[object Object]') {\n    settings = {};\n    type.object = true;\n  }\n\n  if (type.array || type.object) {\n    for (const p in observerSettings) {\n      if (observerSettings.hasOwnProperty(p)) {\n        settings[p] = observerSettings[p];\n      }\n    }\n\n  } else {\n    settings = observerSettings;\n  }\n\n  return settings;\n}\n\n/**\n * Private method to ensure the table is not calling `updateSettings` after editing cells.\n * @private\n */\nexport function preventInternalEditWatch(component) {\n  component.hotInstance.addHook('beforeChange', () => {\n    component.__internalEdit = true;\n  });\n\n  component.hotInstance.addHook('beforeCreateRow', () => {\n    component.__internalEdit = true;\n  });\n\n  component.hotInstance.addHook('beforeCreateCol', () => {\n    component.__internalEdit = true;\n  });\n\n  component.hotInstance.addHook('beforeRemoveRow', () => {\n    component.__internalEdit = true;\n  });\n\n  component.hotInstance.addHook('beforeRemoveCol', () => {\n    component.__internalEdit = true;\n  });\n}\n\n/**\n * Generate an object containing all the available Handsontable properties and plugin hooks.\n *\n * @param {String} source Source for the factory (either 'HotTable' or 'HotColumn').\n * @returns {Object}\n */\nexport function propFactory(source): VueProps<HotTableProps> {\n  const registeredHooks: string[] = Handsontable.hooks.getRegistered();\n\n  const propSchema: VueProps<HotTableProps> = new Handsontable.DefaultSettings();\n\n  for (let prop in propSchema) {\n    propSchema[prop] = {\n      default: unassignedPropSymbol\n    };\n  }\n\n  for (let i = 0; i < registeredHooks.length; i++) {\n    propSchema[registeredHooks[i]] = {\n      default: unassignedPropSymbol\n    };\n  }\n\n  propSchema.settings = {\n    default: unassignedPropSymbol\n  };\n\n  if (source === 'HotTable') {\n    propSchema.id = {\n      type: String,\n      default: 'hot-' + Math.random().toString(36).substring(5)\n    };\n\n    propSchema.wrapperRendererCacheSize = {\n      type: Number,\n      default: 3000\n    };\n  }\n\n  return propSchema;\n}\n\n/**\n * Filter out all of the unassigned props, and return only the one passed to the component.\n *\n * @param {Object} props Object containing all the possible props.\n * @returns {Object} Object containing only used props.\n */\nexport function filterPassedProps(props) {\n  const filteredProps: VueProps<HotTableProps> = {};\n  const columnSettingsProp = props['settings'];\n\n  if (columnSettingsProp !== unassignedPropSymbol) {\n    for (let propName in columnSettingsProp) {\n      if (columnSettingsProp.hasOwnProperty(propName) && columnSettingsProp[propName] !== unassignedPropSymbol) {\n        filteredProps[propName] = columnSettingsProp[propName];\n      }\n    }\n  }\n\n  for (let propName in props) {\n    if (props.hasOwnProperty(propName) && propName !== 'settings' && props[propName] !== unassignedPropSymbol) {\n      filteredProps[propName] = props[propName];\n    }\n  }\n\n  return filteredProps;\n}\n\n/**\n * Prepare the settings object to be used as the settings for Handsontable, based on the props provided to the component.\n *\n * @param {Object} props The props passed to the component.\n * @returns {Object} An object containing the properties, ready to be used within Handsontable.\n */\nexport function prepareSettings(props: HotTableProps): Handsontable.GridSettings {\n  const assignedProps: VueProps<HotTableProps> = filterPassedProps(props);\n  const hotSettingsInProps: {} = props.settings ? props.settings : assignedProps;\n  const additionalHotSettingsInProps: Handsontable.GridSettings = props.settings ? assignedProps : null;\n  const newSettings = {};\n\n  for (const key in hotSettingsInProps) {\n    if (hotSettingsInProps.hasOwnProperty(key) && hotSettingsInProps[key] !== void 0) {\n      newSettings[key] = hotSettingsInProps[key];\n    }\n  }\n\n  for (const key in additionalHotSettingsInProps) {\n    if (key !== 'id' && key !== 'settings' && key !== 'wrapperRendererCacheSize' && additionalHotSettingsInProps.hasOwnProperty(key) && additionalHotSettingsInProps[key] !== void 0) {\n      newSettings[key] = additionalHotSettingsInProps[key];\n    }\n  }\n\n  return newSettings;\n}\n\n/**\n * Get the VNode element with the provided type attribute from the component slots.\n *\n * @param {Array} componentSlots Array of slots from a component.\n * @param {String} type Type of the child component. Either `hot-renderer` or `hot-editor`.\n * @returns {Object|null} The VNode of the child component (or `null` when nothing's found).\n */\nexport function findVNodeByType(componentSlots: VNode[], type: string): VNode {\n  let componentVNode: VNode = null;\n\n  componentSlots.every((slot, index) => {\n    if (slot.data && slot.data.attrs && slot.data.attrs[type] !== void 0) {\n      componentVNode = slot;\n      return false;\n    }\n\n    return true;\n  });\n\n  return componentVNode;\n}\n\n/**\n * Get all `hot-column` component instances from the provided children array.\n *\n * @param {Array} children Array of children from a component.\n * @returns {Array} Array of `hot-column` instances.\n */\nexport function getHotColumnComponents(children) {\n  return children.filter((child) => child.$options.name === 'HotColumn');\n}\n\n/**\n * Create an instance of the Vue Component based on the provided VNode.\n *\n * @param {Object} vNode VNode element to be turned into a component instance.\n * @param {Object} parent Instance of the component to be marked as a parent of the newly created instance.\n * @param {Object} props Props to be passed to the new instance.\n * @param {Object} data Data to be passed to the new instance.\n */\nexport function createVueComponent(vNode: VNode, parent: Vue, props: object, data: object): EditorComponent {\n  const ownerDocument = parent.$el ? parent.$el.ownerDocument : document;\n  const settings: object = {\n    propsData: props,\n    parent,\n    data\n  };\n\n  if (!bulkComponentContainer) {\n    bulkComponentContainer = ownerDocument.createElement('DIV');\n    bulkComponentContainer.id = 'vueHotComponents';\n\n    ownerDocument.body.appendChild(bulkComponentContainer);\n  }\n\n  const componentContainer = ownerDocument.createElement('DIV');\n  bulkComponentContainer.appendChild(componentContainer);\n\n  return (new (vNode.componentOptions as any).Ctor(settings)).$mount(componentContainer);\n}\n","/**\n * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most\n * recently used items while discarding least recently used items when its limit\n * is reached.\n *\n * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>\n * See README.md for details.\n *\n * Illustration of the design:\n *\n *       entry             entry             entry             entry\n *       ______            ______            ______            ______\n *      | head |.newer => |      |.newer => |      |.newer => | tail |\n *      |  A   |          |  B   |          |  C   |          |  D   |\n *      |______| <= older.|______| <= older.|______| <= older.|______|\n *\n *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added\n */\n(function(g,f){\n  const e = typeof exports == 'object' ? exports : typeof g == 'object' ? g : {};\n  f(e);\n  if (typeof define == 'function' && define.amd) { define('lru', e); }\n})(this, function(exports) {\n\n  const NEWER = Symbol('newer');\n  const OLDER = Symbol('older');\n\n  function LRUMap(limit, entries) {\n    if (typeof limit !== 'number') {\n      // called as (entries)\n      entries = limit;\n      limit = 0;\n    }\n\n    this.size = 0;\n    this.limit = limit;\n    this.oldest = this.newest = undefined;\n    this._keymap = new Map();\n\n    if (entries) {\n      this.assign(entries);\n      if (limit < 1) {\n        this.limit = this.size;\n      }\n    }\n  }\n\n  exports.LRUMap = LRUMap;\n\n  function Entry(key, value) {\n    this.key = key;\n    this.value = value;\n    this[NEWER] = undefined;\n    this[OLDER] = undefined;\n  }\n\n\n  LRUMap.prototype._markEntryAsUsed = function(entry) {\n    if (entry === this.newest) {\n      // Already the most recenlty used entry, so no need to update the list\n      return;\n    }\n    // HEAD--------------TAIL\n    //   <.older   .newer>\n    //  <--- add direction --\n    //   A  B  C  <D>  E\n    if (entry[NEWER]) {\n      if (entry === this.oldest) {\n        this.oldest = entry[NEWER];\n      }\n      entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.\n    }\n    if (entry[OLDER]) {\n      entry[OLDER][NEWER] = entry[NEWER]; // C. --> E\n    }\n    entry[NEWER] = undefined; // D --x\n    entry[OLDER] = this.newest; // D. --> E\n    if (this.newest) {\n      this.newest[NEWER] = entry; // E. <-- D\n    }\n    this.newest = entry;\n  };\n\n  LRUMap.prototype.assign = function(entries) {\n    let entry, limit = this.limit || Number.MAX_VALUE;\n    this._keymap.clear();\n    let it = entries[Symbol.iterator]();\n    for (let itv = it.next(); !itv.done; itv = it.next()) {\n      let e = new Entry(itv.value[0], itv.value[1]);\n      this._keymap.set(e.key, e);\n      if (!entry) {\n        this.oldest = e;\n      } else {\n        entry[NEWER] = e;\n        e[OLDER] = entry;\n      }\n      entry = e;\n      if (limit-- == 0) {\n        throw new Error('overflow');\n      }\n    }\n    this.newest = entry;\n    this.size = this._keymap.size;\n  };\n\n  LRUMap.prototype.get = function(key) {\n    // First, find our cache entry\n    var entry = this._keymap.get(key);\n    if (!entry) return; // Not cached. Sorry.\n    // As <key> was found in the cache, register it as being requested recently\n    this._markEntryAsUsed(entry);\n    return entry.value;\n  };\n\n  LRUMap.prototype.set = function(key, value) {\n    var entry = this._keymap.get(key);\n\n    if (entry) {\n      // update existing\n      entry.value = value;\n      this._markEntryAsUsed(entry);\n      return this;\n    }\n\n    // new entry\n    this._keymap.set(key, (entry = new Entry(key, value)));\n\n    if (this.newest) {\n      // link previous tail to the new tail (entry)\n      this.newest[NEWER] = entry;\n      entry[OLDER] = this.newest;\n    } else {\n      // we're first in -- yay\n      this.oldest = entry;\n    }\n\n    // add new entry to the end of the linked list -- it's now the freshest entry.\n    this.newest = entry;\n    ++this.size;\n    if (this.size > this.limit) {\n      // we hit the limit -- remove the head\n      this.shift();\n    }\n\n    return this;\n  };\n\n  LRUMap.prototype.shift = function() {\n    // todo: handle special case when limit == 1\n    var entry = this.oldest;\n    if (entry) {\n      if (this.oldest[NEWER]) {\n        // advance the list\n        this.oldest = this.oldest[NEWER];\n        this.oldest[OLDER] = undefined;\n      } else {\n        // the cache is exhausted\n        this.oldest = undefined;\n        this.newest = undefined;\n      }\n      // Remove last strong reference to <entry> and remove links from the purged\n      // entry being returned:\n      entry[NEWER] = entry[OLDER] = undefined;\n      this._keymap.delete(entry.key);\n      --this.size;\n      return [entry.key, entry.value];\n    }\n  };\n\n// ----------------------------------------------------------------------------\n// Following code is optional and can be removed without breaking the core\n// functionality.\n  LRUMap.prototype.has = function(key) {\n    return this._keymap.has(key);\n  };\n});\n","<template>\n  <div :id=\"id\">\n    <slot></slot>\n  </div>\n</template>\n\n<script lang=\"ts\">\n  import {\n    propFactory,\n    preventInternalEditWatch,\n    prepareSettings,\n    filterPassedProps,\n    createVueComponent,\n    findVNodeByType,\n    getHotColumnComponents\n  } from './helpers';\n  import Vue, { VNode } from 'vue';\n  import {\n    HotTableData,\n    HotTableMethods,\n    HotTableProps,\n    HotTableComponent,\n    VueProps,\n    EditorComponent\n  } from './types';\n  import * as packageJson from '../package.json';\n  import { LRUMap } from './lib/lru/lru';\n  import Handsontable from 'handsontable';\n\n  const HotTable: HotTableComponent<Vue, HotTableData, HotTableMethods, {}, HotTableProps> = {\n    name: 'HotTable',\n    props: propFactory('HotTable'),\n    watch: {\n      mergedHotSettings: function(value) {\n        this.hotInstance.updateSettings(value);\n      }\n    },\n    data: function () {\n      const rendererCache = new LRUMap(this.wrapperRendererCacheSize);\n\n      // Make the LRU cache destroy each removed component\n      rendererCache.shift = function () {\n        let entry = LRUMap.prototype.shift.call(this);\n        entry[1].component.$destroy();\n\n        return entry;\n      };\n\n      return {\n        __internalEdit: false,\n        hotInstance: null,\n        columnSettings: null,\n        rendererCache: rendererCache,\n        editorCache: new Map()\n      }\n    },\n    computed: {\n      mergedHotSettings: function(): Handsontable.GridSettings {\n        return prepareSettings(this.$props);\n      }\n    },\n    methods: {\n      /**\n       * Initialize Handsontable.\n       */\n      hotInit: function (): void {\n        const globalRendererVNode = this.getGlobalRendererVNode();\n        const globalEditorVNode = this.getGlobalEditorVNode();\n\n        const newSettings: Handsontable.GridSettings = prepareSettings(this.$props);\n\n        newSettings.columns = this.columnSettings ? this.columnSettings : newSettings.columns;\n\n        if (globalEditorVNode) {\n          newSettings.editor = this.getEditorClass(globalEditorVNode, this);\n\n          globalEditorVNode.child.$destroy();\n        }\n\n        if (globalRendererVNode) {\n          newSettings.renderer = this.getRendererWrapper(globalRendererVNode, this);\n\n          globalRendererVNode.child.$destroy();\n        }\n\n        this.hotInstance = new Handsontable.Core(this.$el, newSettings);\n        this.hotInstance.init();\n\n        preventInternalEditWatch(this);\n      },\n      getGlobalRendererVNode: function (): VNode | null {\n        const hotTableSlots: VNode[] = this.$slots.default || [];\n        return findVNodeByType(hotTableSlots, 'hot-renderer');\n      },\n      getGlobalEditorVNode: function (): VNode | null {\n        const hotTableSlots: VNode[] = this.$slots.default || [];\n        return findVNodeByType(hotTableSlots, 'hot-editor');\n      },\n      /**\n       * Get settings for the columns provided in the `hot-column` components.\n       */\n      getColumnSettings: function (): HotTableProps[] | void {\n        const hotColumns = getHotColumnComponents(this.$children);\n        let usesRendererComponent = false;\n        let columnSettings: HotTableProps[] = hotColumns.map((elem) => {\n          if (elem.usesRendererComponent) {\n            usesRendererComponent = true;\n          }\n\n          return {...elem.columnSettings};\n        });\n\n        if (usesRendererComponent &&\n          (this.settings && (this.settings.autoColumnSize !== false || this.settings.autoRowSize)) &&\n          (this.autoColumnSize !== false || this.autoRowSize)) {\n          console.warn('Your `hot-table` configuration includes both `hot-column` and `autoRowSize`/`autoColumnSize`, which are not compatible with each other ' +\n            'in this version of `@handsontable/vue`. Disable `autoRowSize` and `autoColumnSize` to prevent row and column misalignment.')\n        }\n\n        return columnSettings.length ? columnSettings : void 0;\n      },\n      /**\n       * Create the wrapper function for the provided renderer child component.\n       *\n       * @param {Object} vNode VNode of the renderer child component.\n       * @param {Boolean} containerComponent Instance of the component, which will be treated as a parent for the newly created renderer component.\n       * @returns {Function} The wrapper function used as the renderer.\n       */\n      getRendererWrapper: function (vNode: VNode, containerComponent: Vue): (...args) => HTMLElement {\n        const $vm = this;\n\n        return function (instance, TD, row, col, prop, value, cellProperties) {\n          // Prevent caching and rendering of the GhostTable table cells\n          if (TD && !TD.getAttribute('ghost-table')) {\n            const rendererCache = $vm.rendererCache;\n            const rendererArgs: object = {\n              hotInstance: instance,\n              TD,\n              row,\n              col,\n              prop,\n              value,\n              cellProperties,\n              isRenderer: true\n            };\n\n            if (rendererCache && !rendererCache.has(`${row}-${col}`)) {\n              const mountedComponent: Vue = createVueComponent(vNode, containerComponent, {}, rendererArgs);\n\n              rendererCache.set(`${row}-${col}`, {\n                component: mountedComponent,\n                lastUsedTD: null\n              });\n            }\n\n            const cachedEntry = rendererCache.get(`${row}-${col}`);\n            const cachedComponent: Vue = cachedEntry.component;\n            const cachedTD: HTMLTableCellElement = cachedEntry.lastUsedTD;\n\n            Object.assign(cachedComponent.$data, rendererArgs);\n\n            if (!cachedComponent.$el.parentElement || cachedTD !== TD) {\n              // Clear the previous contents of a TD\n              while (TD.firstChild) {\n                TD.removeChild(TD.firstChild);\n              }\n\n              TD.appendChild(cachedComponent.$el);\n\n              cachedEntry.lastUsedTD = TD;\n            }\n          }\n\n          return TD;\n        };\n      },\n      /**\n       * Create a fresh class to be used as an editor, based on the editor component provided.\n       *\n       * @param {Object} vNode VNode for the editor child component.\n       * @param {Boolean} containerComponent Instance of the component, which will be treated as a parent for the newly created editor component.\n       * @returns {Class} The class used as an editor in Handsontable.\n       */\n      getEditorClass: function (vNode: VNode, containerComponent: Vue): typeof Handsontable.editors.BaseEditor {\n        const componentName: string = (vNode.componentOptions.Ctor as any).options.name;\n        const editorCache = this.editorCache;\n        let mountedComponent: EditorComponent = null;\n\n        if (!editorCache.has(componentName)) {\n          mountedComponent = createVueComponent(vNode, containerComponent, {}, {isEditor: true});\n\n          editorCache.set(componentName, mountedComponent);\n\n        } else {\n          mountedComponent = editorCache.get(componentName);\n        }\n\n        return mountedComponent.$data.hotCustomEditorClass;\n      },\n    },\n    mounted: function () {\n      this.columnSettings = this.getColumnSettings();\n\n      return this.hotInit();\n    },\n    beforeDestroy: function () {\n      this.hotInstance.destroy();\n    },\n    version: (packageJson as any).version\n  };\n\n  export default HotTable;\n  export { HotTable };\n</script>\n","'use strict';\n\nfunction normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier\n/* server only */\n, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\n  if (typeof shadowMode !== 'boolean') {\n    createInjectorSSR = createInjector;\n    createInjector = shadowMode;\n    shadowMode = false;\n  } // Vue.extend constructor export interop.\n\n\n  var options = typeof script === 'function' ? script.options : script; // render functions\n\n  if (template && template.render) {\n    options.render = template.render;\n    options.staticRenderFns = template.staticRenderFns;\n    options._compiled = true; // functional template\n\n    if (isFunctionalTemplate) {\n      options.functional = true;\n    }\n  } // scopedId\n\n\n  if (scopeId) {\n    options._scopeId = scopeId;\n  }\n\n  var hook;\n\n  if (moduleIdentifier) {\n    // server build\n    hook = function hook(context) {\n      // 2.3 injection\n      context = context || // cached call\n      this.$vnode && this.$vnode.ssrContext || // stateful\n      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional\n      // 2.2 with runInNewContext: true\n\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__;\n      } // inject component styles\n\n\n      if (style) {\n        style.call(this, createInjectorSSR(context));\n      } // register component module identifier for async chunk inference\n\n\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier);\n      }\n    }; // used by ssr in case component is cached and beforeCreate\n    // never gets called\n\n\n    options._ssrRegister = hook;\n  } else if (style) {\n    hook = shadowMode ? function () {\n      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));\n    } : function (context) {\n      style.call(this, createInjector(context));\n    };\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // register for functional component in vue file\n      var originalRender = options.render;\n\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context);\n        return originalRender(h, context);\n      };\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate;\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\n    }\n  }\n\n  return script;\n}\n\nmodule.exports = normalizeComponent;\n//# sourceMappingURL=normalize-component.js.map\n","<script lang=\"ts\">\n  import Vue, { VNode } from 'vue';\n  import { ThisTypedComponentOptionsWithRecordProps } from 'vue/types/options';\n  import {\n    propFactory,\n    findVNodeByType,\n    filterPassedProps\n  } from './helpers';\n  import {\n    HotTableProps,\n    HotColumnMethods,\n  } from './types';\n\n  const HotColumn: ThisTypedComponentOptionsWithRecordProps<Vue, {}, HotColumnMethods, {}, HotTableProps> = {\n    name: 'HotColumn',\n    props: propFactory('HotColumn'),\n    methods: {\n      /**\n       * Create the column settings based on the data provided to the `hot-column` component and it's child components.\n       */\n      createColumnSettings: function (): void {\n        const hotColumnSlots: VNode[] | any[] = this.$slots.default || [];\n        const rendererVNode: VNode | null = findVNodeByType(hotColumnSlots, 'hot-renderer');\n        const editorVNode: VNode | null = findVNodeByType(hotColumnSlots, 'hot-editor');\n        const assignedProps = filterPassedProps(this.$props);\n\n        if (rendererVNode && this.usesRendererComponent === void 0) {\n          this.usesRendererComponent = true;\n        }\n\n        this.columnSettings = {...assignedProps};\n\n        if (rendererVNode !== null) {\n          this.columnSettings.renderer = this.$parent.getRendererWrapper(rendererVNode, this);\n\n        } else if (assignedProps.renderer) {\n          this.columnSettings.renderer = assignedProps.renderer;\n        }\n\n        if (editorVNode !== null) {\n          this.columnSettings.editor = this.$parent.getEditorClass(editorVNode, this);\n\n        } else if (assignedProps.editor) {\n          this.columnSettings.editor = assignedProps.editor;\n        }\n      }\n    },\n    mounted: function () {\n      this.createColumnSettings();\n    },\n    render: function () {\n      return null;\n    }\n  };\n\n  export default HotColumn;\n  export { HotColumn };\n</script>\n","/**\n  * vue-class-component v7.1.0\n  * (c) 2015-present Evan You\n  * @license MIT\n  */\nimport Vue from 'vue';\n\n// The rational behind the verbose Reflect-feature check below is the fact that there are polyfills\n// which add an implementation for Reflect.defineMetadata but not for Reflect.getOwnMetadataKeys.\n// Without this check consumers will encounter hard to track down runtime errors.\nvar reflectionIsSupported = typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;\nfunction copyReflectionMetadata(to, from) {\n    forwardMetadata(to, from);\n    Object.getOwnPropertyNames(from.prototype).forEach(function (key) {\n        forwardMetadata(to.prototype, from.prototype, key);\n    });\n    Object.getOwnPropertyNames(from).forEach(function (key) {\n        forwardMetadata(to, from, key);\n    });\n}\nfunction forwardMetadata(to, from, propertyKey) {\n    var metaKeys = propertyKey\n        ? Reflect.getOwnMetadataKeys(from, propertyKey)\n        : Reflect.getOwnMetadataKeys(from);\n    metaKeys.forEach(function (metaKey) {\n        var metadata = propertyKey\n            ? Reflect.getOwnMetadata(metaKey, from, propertyKey)\n            : Reflect.getOwnMetadata(metaKey, from);\n        if (propertyKey) {\n            Reflect.defineMetadata(metaKey, metadata, to, propertyKey);\n        }\n        else {\n            Reflect.defineMetadata(metaKey, metadata, to);\n        }\n    });\n}\n\nvar fakeArray = { __proto__: [] };\nvar hasProto = fakeArray instanceof Array;\nfunction createDecorator(factory) {\n    return function (target, key, index) {\n        var Ctor = typeof target === 'function'\n            ? target\n            : target.constructor;\n        if (!Ctor.__decorators__) {\n            Ctor.__decorators__ = [];\n        }\n        if (typeof index !== 'number') {\n            index = undefined;\n        }\n        Ctor.__decorators__.push(function (options) { return factory(options, key, index); });\n    };\n}\nfunction mixins() {\n    var Ctors = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        Ctors[_i] = arguments[_i];\n    }\n    return Vue.extend({ mixins: Ctors });\n}\nfunction isPrimitive(value) {\n    var type = typeof value;\n    return value == null || (type !== 'object' && type !== 'function');\n}\nfunction warn(message) {\n    if (typeof console !== 'undefined') {\n        console.warn('[vue-class-component] ' + message);\n    }\n}\n\nfunction collectDataFromConstructor(vm, Component) {\n    // override _init to prevent to init as Vue instance\n    var originalInit = Component.prototype._init;\n    Component.prototype._init = function () {\n        var _this = this;\n        // proxy to actual vm\n        var keys = Object.getOwnPropertyNames(vm);\n        // 2.2.0 compat (props are no longer exposed as self properties)\n        if (vm.$options.props) {\n            for (var key in vm.$options.props) {\n                if (!vm.hasOwnProperty(key)) {\n                    keys.push(key);\n                }\n            }\n        }\n        keys.forEach(function (key) {\n            if (key.charAt(0) !== '_') {\n                Object.defineProperty(_this, key, {\n                    get: function () { return vm[key]; },\n                    set: function (value) { vm[key] = value; },\n                    configurable: true\n                });\n            }\n        });\n    };\n    // should be acquired class property values\n    var data = new Component();\n    // restore original _init to avoid memory leak (#209)\n    Component.prototype._init = originalInit;\n    // create plain data object\n    var plainData = {};\n    Object.keys(data).forEach(function (key) {\n        if (data[key] !== undefined) {\n            plainData[key] = data[key];\n        }\n    });\n    if (process.env.NODE_ENV !== 'production') {\n        if (!(Component.prototype instanceof Vue) && Object.keys(plainData).length > 0) {\n            warn('Component class must inherit Vue or its descendant class ' +\n                'when class property is used.');\n        }\n    }\n    return plainData;\n}\n\nvar $internalHooks = [\n    'data',\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeDestroy',\n    'destroyed',\n    'beforeUpdate',\n    'updated',\n    'activated',\n    'deactivated',\n    'render',\n    'errorCaptured',\n    'serverPrefetch' // 2.6\n];\nfunction componentFactory(Component, options) {\n    if (options === void 0) { options = {}; }\n    options.name = options.name || Component._componentTag || Component.name;\n    // prototype props.\n    var proto = Component.prototype;\n    Object.getOwnPropertyNames(proto).forEach(function (key) {\n        if (key === 'constructor') {\n            return;\n        }\n        // hooks\n        if ($internalHooks.indexOf(key) > -1) {\n            options[key] = proto[key];\n            return;\n        }\n        var descriptor = Object.getOwnPropertyDescriptor(proto, key);\n        if (descriptor.value !== void 0) {\n            // methods\n            if (typeof descriptor.value === 'function') {\n                (options.methods || (options.methods = {}))[key] = descriptor.value;\n            }\n            else {\n                // typescript decorated data\n                (options.mixins || (options.mixins = [])).push({\n                    data: function () {\n                        var _a;\n                        return _a = {}, _a[key] = descriptor.value, _a;\n                    }\n                });\n            }\n        }\n        else if (descriptor.get || descriptor.set) {\n            // computed properties\n            (options.computed || (options.computed = {}))[key] = {\n                get: descriptor.get,\n                set: descriptor.set\n            };\n        }\n    });\n    (options.mixins || (options.mixins = [])).push({\n        data: function () {\n            return collectDataFromConstructor(this, Component);\n        }\n    });\n    // decorate options\n    var decorators = Component.__decorators__;\n    if (decorators) {\n        decorators.forEach(function (fn) { return fn(options); });\n        delete Component.__decorators__;\n    }\n    // find super\n    var superProto = Object.getPrototypeOf(Component.prototype);\n    var Super = superProto instanceof Vue\n        ? superProto.constructor\n        : Vue;\n    var Extended = Super.extend(options);\n    forwardStaticMembers(Extended, Component, Super);\n    if (reflectionIsSupported) {\n        copyReflectionMetadata(Extended, Component);\n    }\n    return Extended;\n}\nvar reservedPropertyNames = [\n    // Unique id\n    'cid',\n    // Super Vue constructor\n    'super',\n    // Component options that will be used by the component\n    'options',\n    'superOptions',\n    'extendOptions',\n    'sealedOptions',\n    // Private assets\n    'component',\n    'directive',\n    'filter'\n];\nvar shouldIgnore = {\n    prototype: true,\n    arguments: true,\n    callee: true,\n    caller: true\n};\nfunction forwardStaticMembers(Extended, Original, Super) {\n    // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable\n    Object.getOwnPropertyNames(Original).forEach(function (key) {\n        // Skip the properties that should not be overwritten\n        if (shouldIgnore[key]) {\n            return;\n        }\n        // Some browsers does not allow reconfigure built-in properties\n        var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);\n        if (extendedDescriptor && !extendedDescriptor.configurable) {\n            return;\n        }\n        var descriptor = Object.getOwnPropertyDescriptor(Original, key);\n        // If the user agent does not support `__proto__` or its family (IE <= 10),\n        // the sub class properties may be inherited properties from the super class in TypeScript.\n        // We need to exclude such properties to prevent to overwrite\n        // the component options object which stored on the extended constructor (See #192).\n        // If the value is a referenced value (object or function),\n        // we can check equality of them and exclude it if they have the same reference.\n        // If it is a primitive value, it will be forwarded for safety.\n        if (!hasProto) {\n            // Only `cid` is explicitly exluded from property forwarding\n            // because we cannot detect whether it is a inherited property or not\n            // on the no `__proto__` environment even though the property is reserved.\n            if (key === 'cid') {\n                return;\n            }\n            var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);\n            if (!isPrimitive(descriptor.value) &&\n                superDescriptor &&\n                superDescriptor.value === descriptor.value) {\n                return;\n            }\n        }\n        // Warn if the users manually declare reserved properties\n        if (process.env.NODE_ENV !== 'production' &&\n            reservedPropertyNames.indexOf(key) >= 0) {\n            warn(\"Static property name '\" + key + \"' declared on class '\" + Original.name + \"' \" +\n                'conflicts with reserved property name of Vue internal. ' +\n                'It may cause unexpected behavior of the component. Consider renaming the property.');\n        }\n        Object.defineProperty(Extended, key, descriptor);\n    });\n}\n\nfunction Component(options) {\n    if (typeof options === 'function') {\n        return componentFactory(options);\n    }\n    return function (Component) {\n        return componentFactory(Component, options);\n    };\n}\nComponent.registerHooks = function registerHooks(keys) {\n    $internalHooks.push.apply($internalHooks, keys);\n};\n\nexport default Component;\nexport { createDecorator, mixins };\n","<script lang=\"ts\">\n  import Vue from 'vue';\n  import Handsontable from 'handsontable';\n  import Component from 'vue-class-component';\n\n  @Component({})\n  class BaseEditorComponent extends Vue implements Handsontable._editors.Base {\n    name = 'BaseEditorComponent';\n    instance = null;\n    row = null;\n    col = null;\n    prop = null;\n    TD = null;\n    originalValue = null;\n    cellProperties = null;\n    state = null;\n    hot = null;\n\n    mounted() {\n      const _this = this;\n\n      this.$data.hotCustomEditorClass = function () {\n        const customEditorClass = class CustomEditor extends Handsontable.editors.BaseEditor implements Handsontable._editors.Base {\n          constructor(hotInstance, row, col, prop, TD, cellProperties) {\n            super(hotInstance, row, col, prop, TD, cellProperties);\n\n            _this.$data.hotCustomEditorInstance = this;\n          }\n\n          focus() {\n          }\n\n          getValue() {\n          }\n\n          setValue() {\n          }\n\n          open() {\n          }\n\n          close() {\n          }\n        } as any;\n\n        // Fill with the rest of the BaseEditorComponent methods\n        Object.getOwnPropertyNames(Handsontable.editors.BaseEditor.prototype).forEach(propName => {\n          if (propName === 'constructor') {\n            return;\n          }\n\n          customEditorClass.prototype[propName] = function (...args) {\n            return _this[propName].call(this, ...args);\n          }\n        });\n\n        return customEditorClass;\n      }();\n    }\n\n    // BaseEditorComponent methods:\n    private _fireCallbacks(...args) {\n      (Handsontable.editors.BaseEditor.prototype as any)._fireCallbacks.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    beginEditing(...args) {\n      return Handsontable.editors.BaseEditor.prototype.beginEditing.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    cancelChanges(...args) {\n      return Handsontable.editors.BaseEditor.prototype.cancelChanges.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    checkEditorSection(...args) {\n      return Handsontable.editors.BaseEditor.prototype.checkEditorSection.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    close(...args) {\n      return Handsontable.editors.BaseEditor.prototype.close.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    discardEditor(...args) {\n      return Handsontable.editors.BaseEditor.prototype.discardEditor.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    enableFullEditMode(...args) {\n      return Handsontable.editors.BaseEditor.prototype.enableFullEditMode.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    extend(...args) {\n      return Handsontable.editors.BaseEditor.prototype.extend.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    finishEditing(...args) {\n      return Handsontable.editors.BaseEditor.prototype.finishEditing.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    focus(...args) {\n      return Handsontable.editors.BaseEditor.prototype.focus.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    getValue(...args) {\n      return Handsontable.editors.BaseEditor.prototype.getValue.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    init(...args) {\n      return Handsontable.editors.BaseEditor.prototype.init.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    isInFullEditMode(...args) {\n      return Handsontable.editors.BaseEditor.prototype.isInFullEditMode.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    isOpened(...args) {\n      return Handsontable.editors.BaseEditor.prototype.isOpened.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    isWaiting(...args) {\n      return Handsontable.editors.BaseEditor.prototype.isWaiting.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    open(...args) {\n      return Handsontable.editors.BaseEditor.prototype.open.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    prepare(row, col, prop, TD, originalValue, cellProperties) {\n      this.$data.hotInstance = cellProperties.instance;\n      this.$data.row = row;\n      this.$data.col = col;\n      this.$data.prop = prop;\n      this.$data.TD = TD;\n      this.$data.originalValue = originalValue;\n      this.$data.cellProperties = cellProperties;\n\n      return Handsontable.editors.BaseEditor.prototype.prepare.call(this.$data.hotCustomEditorInstance, row, col, prop, TD, originalValue, cellProperties);\n    }\n\n    saveValue(...args) {\n      return Handsontable.editors.BaseEditor.prototype.saveValue.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    setValue(...args) {\n      return Handsontable.editors.BaseEditor.prototype.setValue.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    addHook(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).addHook.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    removeHooksByKey(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).removeHooksByKey.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    clearHooks(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).clearHooks.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    getEditedCell(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).getEditedCell.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    getEditedCellsZIndex(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).getEditedCellsZIndex.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n\n    getEditedCellsLayerClass(...args) {\n      return (Handsontable.editors.BaseEditor.prototype as any).getEditedCellsLayerClass.call(this.$data.hotCustomEditorInstance, ...args);\n    }\n  }\n\n  export default BaseEditorComponent;\n  export { BaseEditorComponent };\n</script>\n"],"names":["unassignedPropSymbol","Symbol","bulkComponentContainer","preventInternalEditWatch","component","hotInstance","addHook","__internalEdit","propFactory","source","registeredHooks","Handsontable","hooks","getRegistered","propSchema","DefaultSettings","prop","i","length","settings","id","type","String","Math","random","toString","substring","wrapperRendererCacheSize","Number","filterPassedProps","props","filteredProps","columnSettingsProp","propName","hasOwnProperty","prepareSettings","assignedProps","hotSettingsInProps","additionalHotSettingsInProps","newSettings","key","findVNodeByType","componentSlots","componentVNode","every","slot","index","data","attrs","getHotColumnComponents","children","filter","child","$options","name","createVueComponent","vNode","parent","ownerDocument","$el","document","propsData","createElement","body","appendChild","componentContainer","componentOptions","Ctor","$mount","g","f","e","exports","this","NEWER","OLDER","LRUMap","limit","entries","size","oldest","newest","undefined","_keymap","Map","assign","Entry","value","prototype","_markEntryAsUsed","entry","MAX_VALUE","clear","it","iterator","itv","next","done","set","Error","get","shift","has"],"mappings":"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"}