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

package/helpers.d.ts

@@ -0,0 +1,65 @@
+import Vue, { VNode } from 'vue';
+import Handsontable from 'handsontable/base';
+import { HotTableProps, VueProps, EditorComponent } from './types';
+/**
+ * Message for the warning thrown if the Handsontable instance has been destroyed.
+ */
+export declare const HOT_DESTROYED_WARNING: string;
+/**
+ * Rewrite the settings object passed to the watchers to be a clean array/object prepared to use within Handsontable config.
+ *
+ * @param {*} observerSettings Watcher object containing the changed data.
+ * @returns {Object|Array}
+ */
+export declare function rewriteSettings(observerSettings: any): any[] | object;
+/**
+ * Private method to ensure the table is not calling `updateSettings` after editing cells.
+ * @private
+ */
+export declare function preventInternalEditWatch(component: any): void;
+/**
+ * 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: any): 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): Handsontable.GridSettings;
+/**
+ * Get the VNode element with the provided type attribute from the component slots.
+ *
+ * @param {Array} componentSlots Array of slots from a component.
+ * @param {String} type Type of the child component. Either `hot-renderer` or `hot-editor`.
+ * @returns {Object|null} The VNode of the child component (or `null` when nothing's found).
+ */
+export declare function findVNodeByType(componentSlots: VNode[], type: string): VNode;
+/**
+ * Get all `hot-column` component instances from the provided children array.
+ *
+ * @param {Array} children Array of children from a component.
+ * @returns {Array} Array of `hot-column` instances.
+ */
+export declare function getHotColumnComponents(children: any): any;
+/**
+ * Create an instance of the Vue Component based on the provided VNode.
+ *
+ * @param {Object} vNode VNode element to be turned into a component instance.
+ * @param {Object} parent Instance of the component to be marked as a parent of the newly created instance.
+ * @param {Object} props Props to be passed to the new instance.
+ * @param {Object} data Data to be passed to the new instance.
+ */
+export declare function createVueComponent(vNode: VNode, parent: Vue, props: object, data: object): EditorComponent;

package/index.d.ts

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

package/package.json

@@ -0,0 +1,133 @@
+{
+  "name": "@handsontable/vue",
+  "version": "0.0.0-next-9ec04ce-20221121",
+  "description": "Best Data Grid for Vue with Spreadsheet Look and Feel.",
+  "author": "Handsoncode <hello@handsoncode.net> (https://handsoncode.net)",
+  "homepage": "https://handsontable.com",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "main": "./commonjs/vue-handsontable.js",
+  "module": "./es/vue-handsontable.js",
+  "jsdelivr": "./dist/vue-handsontable.min.js",
+  "unpkg": "./dist/vue-handsontable.min.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./dist/vue-handsontable.js": "./dist/vue-handsontable.js",
+    "./dist/vue-handsontable.min.js": "./dist/vue-handsontable.min.js",
+    ".": {
+      "import": "./es/vue-handsontable.mjs",
+      "require": "./commonjs/vue-handsontable.js"
+    }
+  },
+  "keywords": [
+    "handsontable",
+    "component",
+    "data",
+    "table",
+    "grid",
+    "data table",
+    "data grid",
+    "spreadsheet",
+    "sheet",
+    "excel",
+    "vue",
+    "vue.js",
+    "vuejs",
+    "vue2",
+    "vue component",
+    "vue grid",
+    "wrapper",
+    "enterprise",
+    "sort",
+    "formulas",
+    "filter",
+    "search",
+    "conditional formatting",
+    "csv"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/handsontable/handsontable.git"
+  },
+  "bugs": {
+    "url": "https://github.com/handsontable/handsontable/issues"
+  },
+  "peerDependencies": {
+    "handsontable": "0.0.0-next-9ec04ce-20221121",
+    "vue": "^2.5.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.4.4",
+    "@babel/core": "^7.4.5",
+    "@babel/plugin-transform-runtime": "^7.4.4",
+    "@babel/polyfill": "^7.4.4",
+    "@babel/preset-env": "^7.4.5",
+    "@babel/preset-typescript": "^7.3.3",
+    "@babel/runtime": "^7.4.5",
+    "@vue/test-utils": "^1.0.3",
+    "babel-core": "^7.0.0-bridge.0",
+    "cpy-cli": "^3.1.1",
+    "cross-env": "^5.2.0",
+    "css-loader": "^3.0.0",
+    "del-cli": "^3.0.1",
+    "handsontable": "0.0.0-next-9ec04ce-20221121",
+    "jest": "^26.6.3",
+    "resize-observer-polyfill": "^1.5.1",
+    "rollup": "^2.0.0",
+    "rollup-plugin-babel": "^4.3.2",
+    "rollup-plugin-cleanup": "^3.1.1",
+    "rollup-plugin-commonjs": "^10.0.0",
+    "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-node-resolve": "^5.0.2",
+    "rollup-plugin-replace": "^2.2.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript": "^1.0.1",
+    "rollup-plugin-typescript2": "^0.21.1",
+    "rollup-plugin-vue": "^5.0.0",
+    "typescript": "3.8.2",
+    "vue": "~2.6.10",
+    "vue-class-component": "^7.1.0",
+    "vue-jest": "^3.0.4",
+    "vue-router": "^3.0.6",
+    "vue-template-compiler": "~2.6.10",
+    "vuex": "^3.1.1"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run build:commonjs && npm run build:es && npm run build:umd && npm run build:min",
+    "build:commonjs": "cross-env NODE_ENV=cjs rollup -c",
+    "build:umd": "cross-env NODE_ENV=umd rollup -c",
+    "build:es": "cross-env NODE_ENV=es rollup -c",
+    "build:min": "cross-env NODE_ENV=min rollup -c",
+    "build:esDts": "cross-env NODE_ENV=esDts rollup -c && del-cli ./buildTemp/",
+    "watch:commonjs": "cross-env NODE_ENV=cjs rollup -c --watch",
+    "watch:es": "cross-env NODE_ENV=es rollup -c --watch",
+    "watch:umd": "cross-env NODE_ENV=umd rollup -c --watch",
+    "clean": "del-cli ./es/ && del-cli ./commonjs/ && del-cli ./dist/ && del-cli ./*.d.ts",
+    "publish-package": "npm publish",
+    "test": "jest"
+  },
+  "jest": {
+    "testURL": "http://localhost/",
+    "transform": {
+      "^.+\\.ts?$": "babel-jest",
+      "^.+\\.js$": "babel-jest",
+      ".*\\.vue$": "vue-jest"
+    },
+    "testRegex": "(/test/(.*).(test|spec)).(js?|ts?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "js",
+      "json",
+      "vue",
+      "node"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/bootstrap.js"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsConfig": "test-tsconfig.json",
+        "babelConfig": true
+      }
+    }
+  }
+}

package/types.d.ts

@@ -0,0 +1,60 @@
+import Handsontable from 'handsontable/base';
+import Vue, { VNode } from 'vue';
+import { ThisTypedComponentOptionsWithRecordProps } from 'vue/types/options';
+export interface HotTableData {
+    __internalEdit: boolean;
+    __hotInstance: Handsontable | null;
+    miscCache?: {
+        currentSourceColumns?: number;
+    };
+    hotInstance?: Handsontable | null;
+    columnSettings: HotTableProps[];
+    rendererCache: any;
+    editorCache: Map<string, EditorComponent>;
+}
+export interface HotTableMethods {
+    hotInit: () => void;
+    getColumnSettings: () => HotTableProps[] | void;
+    getGlobalRendererVNode: () => VNode | void;
+    getGlobalEditorVNode: () => VNode | void;
+    getRendererWrapper: (vNode: VNode, containerComponent: Vue) => (...args: any[]) => HTMLElement;
+    getEditorClass: (vNode: VNode, containerComponent: Vue) => typeof Handsontable.editors.BaseEditor;
+    matchHotMappersSize: () => void;
+}
+export interface HotTableProps extends Handsontable.GridSettings {
+    id?: string;
+    settings?: Handsontable.GridSettings;
+    wrapperRendererCacheSize?: number;
+}
+export interface HotTableComponent<V extends Vue, D, M, C, P> extends ThisTypedComponentOptionsWithRecordProps<V, D, M, C, P> {
+    version: string;
+}
+export interface HotColumnMethods {
+    createColumnSettings: () => void;
+}
+export interface EditorComponent extends Vue {
+    focus(): void;
+    open(event?: Event): void;
+    close(): void;
+    getValue(): any;
+    setValue(newValue?: any): void;
+    [additional: string]: any;
+}
+export declare type VueProps<T> = {
+    [P in keyof T]: any;
+};
+declare type ClassMethodKey<T> = ({
+    [P in keyof T]: T[P] extends Function ? P : never;
+})[keyof T];
+declare type NonConstructorClassMethodKey<T> = Exclude<ClassMethodKey<T>, 'constructor'>;
+declare type NotOriginalValueProp<T> = Exclude<NonConstructorClassMethodKey<T>, 'originalValue'>;
+declare type ClassFieldKey<T> = ({
+    [P in keyof T]: T[P] extends Function ? never : P;
+})[keyof T];
+declare type ClassMethods<T> = Pick<T, NotOriginalValueProp<T>>;
+declare type ClassFields<T> = Pick<T, ClassFieldKey<T>>;
+export interface BaseVueEditorMethods extends ClassMethods<Handsontable._editors.Base> {
+}
+export interface BaseVueEditorFields extends ClassFields<Handsontable._editors.Base> {
+}
+export {};