@datagrok-libraries/utils 1.11.1 → 1.12.2

package/src/history-utils.d.ts

@@ -0,0 +1,36 @@
+import * as DG from 'datagrok-api/dg';
+import { FilterOptions } from './function-view';
+export declare namespace historyUtils {
+    function loadRun(funcCallId: string): Promise<DG.FuncCall>;
+    function saveRun(callToSave: DG.FuncCall): Promise<DG.FuncCall>;
+    function deleteRun(callToDelete: DG.FuncCall): Promise<void>;
+    /**
+     * Loads all the function call of this function.
+     * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.
+     * WARNING: FuncCall inputs/outputs fields are not included
+     * @param funcId ID of Func which calls we are looking for. Get it using {@link func.id} field
+     * @return Promise on array of FuncCalls corresponding to the passed Func ID
+     * @stability Deprecated. Script ID changes with every package release, so searching by ID is useless in practice.
+   */
+    function pullRuns(funcId: string, filterOptions?: FilterOptions, listOptions?: {
+        pageSize?: number;
+        pageNumber?: number;
+        filter?: string;
+        order?: string;
+    }): Promise<DG.FuncCall[]>;
+    /**
+     * Loads all the function call of this function.
+     * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.
+     * WARNING: FuncCall inputs/outputs fields are not included
+     * @param funcName Name of Func which calls we are looking for. Get it using {@link func.name} field
+     * @return Promise on array of FuncCalls corresponding to the passed Func ID
+     * @stability Experimental
+   */
+    function pullRunsByName(funcName: string, filterOptions?: FilterOptions, listOptions?: {
+        pageSize?: number;
+        pageNumber?: number;
+        filter?: string;
+        order?: string;
+    }): Promise<DG.FuncCall[]>;
+}
+//# sourceMappingURL=history-utils.d.ts.map

package/src/history-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-utils.d.ts","sourceRoot":"","sources":["history-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEtC,OAAO,EAAc,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAyB3D,yBAAiB,YAAY,CAAC;IAC5B,SAAsB,OAAO,CAAC,UAAU,EAAE,MAAM,wBAkB/C;IAED,SAAsB,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,QAAQ,wBAYpD;IAED,SAAsB,SAAS,CAAC,YAAY,EAAE,EAAE,CAAC,QAAQ,iBAExD;IAED;;;;;;;KAOC;IACD,SAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,aAAkB,EACjC,WAAW,GAAE;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAM,GAC1F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAOxB;IAED;;;;;;;KAOC;IACD,SAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,aAAa,GAAE,aAAkB,EACjC,WAAW,GAAE;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAM,GAC1F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAQxB;CACF"}

package/src/history-utils.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable valid-jsdoc */
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import wu from 'wu';
+const getSearchStringByPattern = (datePattern) => {
+    switch (datePattern) {
+        case 'Today':
+            return ` and started > -1d`;
+        case 'Yesterday':
+            return ` and started > -2d and started < -1d`;
+        case 'Any time':
+            return ``;
+        case 'Last year':
+            return `and started > -2y and started < -1y`;
+        case 'This year':
+            return ` and started > -1y`;
+        case 'Last month':
+            return ` and started > -2m and started < -1m`;
+        case 'This month':
+            return ` and started > -1m`;
+        case 'Last week':
+            return ` and started > -2w and started < -1w`;
+        case 'This week':
+            return ` and started > -1w`;
+    }
+};
+export var historyUtils;
+(function (historyUtils) {
+    function loadRun(funcCallId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pulledRun = yield grok.dapi.functions.calls.include('inputs, outputs').find(funcCallId);
+            // FIX ME: manually get script since pulledRun contains empty Func
+            const script = yield grok.dapi.functions.find(pulledRun.func.id);
+            //@ts-ignore
+            window.grok_FuncCall_Set_Func(pulledRun.dart, script.dart);
+            pulledRun.options['isHistorical'] = true;
+            const dfOutputs = wu(pulledRun.outputParams.values())
+                .filter((output) => output.property.propertyType === DG.TYPE.DATA_FRAME);
+            for (const output of dfOutputs)
+                pulledRun.outputs[output.name] = yield grok.dapi.tables.getTable(pulledRun.outputs[output.name]);
+            const dfInputs = wu(pulledRun.inputParams.values())
+                .filter((input) => input.property.propertyType === DG.TYPE.DATA_FRAME);
+            for (const input of dfInputs)
+                pulledRun.inputs[input.name] = yield grok.dapi.tables.getTable(pulledRun.inputs[input.name]);
+            return pulledRun;
+        });
+    }
+    historyUtils.loadRun = loadRun;
+    function saveRun(callToSave) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dfOutputs = wu(callToSave.outputParams.values())
+                .filter((output) => output.property.propertyType === DG.TYPE.DATA_FRAME);
+            for (const output of dfOutputs)
+                yield grok.dapi.tables.uploadDataFrame(callToSave.outputs[output.name]);
+            const dfInputs = wu(callToSave.inputParams.values())
+                .filter((input) => input.property.propertyType === DG.TYPE.DATA_FRAME);
+            for (const input of dfInputs)
+                yield grok.dapi.tables.uploadDataFrame(callToSave.inputs[input.name]);
+            return yield grok.dapi.functions.calls.save(callToSave);
+        });
+    }
+    historyUtils.saveRun = saveRun;
+    function deleteRun(callToDelete) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield grok.dapi.functions.calls.delete(callToDelete);
+        });
+    }
+    historyUtils.deleteRun = deleteRun;
+    /**
+     * Loads all the function call of this function.
+     * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.
+     * WARNING: FuncCall inputs/outputs fields are not included
+     * @param funcId ID of Func which calls we are looking for. Get it using {@link func.id} field
+     * @return Promise on array of FuncCalls corresponding to the passed Func ID
+     * @stability Deprecated. Script ID changes with every package release, so searching by ID is useless in practice.
+   */
+    function pullRuns(funcId, filterOptions = {}, listOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let filteringString = `func.id="${funcId}"`;
+            filteringString += filterOptions.author ? ` and session.user.id="${filterOptions.author.id}"` : '';
+            filteringString += filterOptions.date ? getSearchStringByPattern(filterOptions.date) : '';
+            const filter = grok.dapi.functions.calls.filter(filteringString).include('session.user, options');
+            const list = filter.list(listOptions);
+            return list;
+        });
+    }
+    historyUtils.pullRuns = pullRuns;
+    /**
+     * Loads all the function call of this function.
+     * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.
+     * WARNING: FuncCall inputs/outputs fields are not included
+     * @param funcName Name of Func which calls we are looking for. Get it using {@link func.name} field
+     * @return Promise on array of FuncCalls corresponding to the passed Func ID
+     * @stability Experimental
+   */
+    function pullRunsByName(funcName, filterOptions = {}, listOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let filteringString = `func.name="${funcName}"`;
+            filteringString += filterOptions.author ? ` and session.user.id="${filterOptions.author.id}"` : '';
+            filteringString += filterOptions.date ? getSearchStringByPattern(filterOptions.date) : '';
+            filteringString += filterOptions.isShared ? `and options.isShared="true"` : '';
+            const filter = grok.dapi.functions.calls.filter(filteringString).include('session.user, options');
+            const list = filter.list(listOptions);
+            return list;
+        });
+    }
+    historyUtils.pullRunsByName = pullRunsByName;
+})(historyUtils || (historyUtils = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"history-utils.js","sourceRoot":"","sources":["history-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable valid-jsdoc */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport wu from 'wu';\nimport {DateOptions, FilterOptions} from './function-view';\n\nconst getSearchStringByPattern = (datePattern: DateOptions) => {\n  switch (datePattern) {\n  case 'Today':\n    return ` and started > -1d`;\n  case 'Yesterday':\n    return ` and started > -2d and started < -1d`;\n  case 'Any time':\n    return ``;\n  case 'Last year':\n    return `and started > -2y and started < -1y`;\n  case 'This year':\n    return ` and started > -1y`;\n  case 'Last month':\n    return ` and started > -2m and started < -1m`;\n  case 'This month':\n    return ` and started > -1m`;\n  case 'Last week':\n    return ` and started > -2w and started < -1w`;\n  case 'This week':\n    return ` and started > -1w`;\n  }\n};\n\nexport namespace historyUtils {\n  export async function loadRun(funcCallId: string) {\n    const pulledRun = await grok.dapi.functions.calls.include('inputs, outputs').find(funcCallId);\n    // FIX ME: manually get script since pulledRun contains empty Func\n    const script = await grok.dapi.functions.find(pulledRun.func.id);\n    //@ts-ignore\n    window.grok_FuncCall_Set_Func(pulledRun.dart, script.dart);\n    pulledRun.options['isHistorical'] = true;\n    const dfOutputs = wu(pulledRun.outputParams.values() as DG.FuncCallParam[])\n      .filter((output) => output.property.propertyType === DG.TYPE.DATA_FRAME);\n    for (const output of dfOutputs)\n      pulledRun.outputs[output.name] = await grok.dapi.tables.getTable(pulledRun.outputs[output.name]);\n\n    const dfInputs = wu(pulledRun.inputParams.values() as DG.FuncCallParam[])\n      .filter((input) => input.property.propertyType === DG.TYPE.DATA_FRAME);\n    for (const input of dfInputs)\n      pulledRun.inputs[input.name] = await grok.dapi.tables.getTable(pulledRun.inputs[input.name]);\n\n    return pulledRun;\n  }\n\n  export async function saveRun(callToSave: DG.FuncCall) {\n    const dfOutputs = wu(callToSave.outputParams.values() as DG.FuncCallParam[])\n      .filter((output) => output.property.propertyType === DG.TYPE.DATA_FRAME);\n    for (const output of dfOutputs)\n      await grok.dapi.tables.uploadDataFrame(callToSave.outputs[output.name]);\n\n    const dfInputs = wu(callToSave.inputParams.values() as DG.FuncCallParam[])\n      .filter((input) => input.property.propertyType === DG.TYPE.DATA_FRAME);\n    for (const input of dfInputs)\n      await grok.dapi.tables.uploadDataFrame(callToSave.inputs[input.name]);\n\n    return await grok.dapi.functions.calls.save(callToSave);\n  }\n\n  export async function deleteRun(callToDelete: DG.FuncCall) {\n    await grok.dapi.functions.calls.delete(callToDelete);\n  }\n\n  /**\n   * Loads all the function call of this function.\n   * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.\n   * WARNING: FuncCall inputs/outputs fields are not included\n   * @param funcId ID of Func which calls we are looking for. Get it using {@link func.id} field\n   * @return Promise on array of FuncCalls corresponding to the passed Func ID\n   * @stability Deprecated. Script ID changes with every package release, so searching by ID is useless in practice.\n */\n  export async function pullRuns(\n    funcId: string,\n    filterOptions: FilterOptions = {},\n    listOptions: {pageSize?: number, pageNumber?: number, filter?: string, order?: string} = {}\n  ): Promise<DG.FuncCall[]> {\n    let filteringString = `func.id=\"${funcId}\"`;\n    filteringString += filterOptions.author ? ` and session.user.id=\"${filterOptions.author.id}\"`:'';\n    filteringString += filterOptions.date ? getSearchStringByPattern(filterOptions.date): '';\n    const filter = grok.dapi.functions.calls.filter(filteringString).include('session.user, options');\n    const list = filter.list(listOptions);\n    return list;\n  }\n\n  /**\n   * Loads all the function call of this function.\n   * Designed to pull hstorical runs in fast manner and the call {@link loadRun} with specified run ID.\n   * WARNING: FuncCall inputs/outputs fields are not included\n   * @param funcName Name of Func which calls we are looking for. Get it using {@link func.name} field\n   * @return Promise on array of FuncCalls corresponding to the passed Func ID\n   * @stability Experimental\n */\n  export async function pullRunsByName(\n    funcName: string,\n    filterOptions: FilterOptions = {},\n    listOptions: {pageSize?: number, pageNumber?: number, filter?: string, order?: string} = {}\n  ): Promise<DG.FuncCall[]> {\n    let filteringString = `func.name=\"${funcName}\"`;\n    filteringString += filterOptions.author ? ` and session.user.id=\"${filterOptions.author.id}\"`:'';\n    filteringString += filterOptions.date ? getSearchStringByPattern(filterOptions.date): '';\n    filteringString += filterOptions.isShared ? `and options.isShared=\"true\"`: '';\n    const filter = grok.dapi.functions.calls.filter(filteringString).include('session.user, options');\n    const list = filter.list(listOptions);\n    return list;\n  }\n}\n"]}

package/src/shared-components/file-input.d.ts

@@ -1,5 +1,6 @@
 import { Subject } from 'rxjs';
 import '../../css/shared-components.css';
+import Validation from '../validation';
 export declare const EXCEL_BLOB_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 export declare class FileInput {
     initialText: string;
@@ -7,10 +8,13 @@ export declare class FileInput {
     onValueChanged: Function | null;
     fileType: string;
     uploadedFile$: Subject<File | null>;
+    onFileUploaded: Subject<File | null>;
     root: HTMLDivElement;
+    validation: Validation<File>;
     private visibleInput;
     private hiddenInput;
     private icon;
+    private isValid;
     constructor(initialText?: string, initialValue?: File | null, onValueChanged?: Function | null, fileType?: string);
     private draw;
     private reset;

package/src/shared-components/file-input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-input.d.ts","sourceRoot":"","sources":["file-input.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAC7B,OAAO,iCAAiC,CAAC;AAEzC,eAAO,MAAM,eAAe,sEAAsE,CAAC;AAEnG,qBAAa,SAAS;IAWX,WAAW;IACX,YAAY,EAAE,IAAI,GAAG,IAAI;IACzB,cAAc,EAAE,QAAQ,GAAG,IAAI;IAC/B,QAAQ;IAZV,aAAa,uBAA8B;IAE3C,IAAI,iBAAY;IAEvB,OAAO,CAAC,YAAY,CAAwD;IAC5E,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,IAAI,CAA6D;gBAGhE,WAAW,SAAqB,EAChC,YAAY,GAAE,IAAI,GAAG,IAAW,EAChC,cAAc,GAAE,QAAQ,GAAG,IAAW,EACtC,QAAQ,SAAkB;IAQnC,OAAO,CAAC,IAAI;IA2FZ,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,KAAK;CAGd"}
+{"version":3,"file":"file-input.d.ts","sourceRoot":"","sources":["file-input.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,OAAO,EAAC,MAAM,MAAM,CAAC;AAC9C,OAAO,iCAAiC,CAAC;AACzC,OAAO,UAAU,MAAM,eAAe,CAAC;AAEvC,eAAO,MAAM,eAAe,sEAAsE,CAAC;AAEnG,qBAAa,SAAS;IAiBX,WAAW;IACX,YAAY,EAAE,IAAI,GAAG,IAAI;IACzB,cAAc,EAAE,QAAQ,GAAG,IAAI;IAC/B,QAAQ;IAlBV,aAAa,uBAA8B;IAE3C,cAAc,uBAA8B;IAE5C,IAAI,iBAAY;IAEhB,UAAU,mBAA0B;IAE3C,OAAO,CAAC,YAAY,CAAwD;IAC5E,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,IAAI,CAA6D;IAEzE,OAAO,CAAC,OAAO,CAAsC;gBAG5C,WAAW,SAAqB,EAChC,YAAY,GAAE,IAAI,GAAG,IAAW,EAChC,cAAc,GAAE,QAAQ,GAAG,IAAW,EACtC,QAAQ,SAAkB;IA0BnC,OAAO,CAAC,IAAI;IAoFZ,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,KAAK;CAGd"}

package/src/shared-components/file-input.js

@@ -8,8 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as ui from 'datagrok-api/ui';
-import { Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import '../../css/shared-components.css';
+import Validation from '../validation';
 export const EXCEL_BLOB_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
 export class FileInput {
     constructor(initialText = 'Drag-n-drop here', initialValue = null, onValueChanged = null, fileType = EXCEL_BLOB_TYPE) {
@@ -19,11 +20,34 @@ export class FileInput {
         this.fileType = fileType;
         // events to emit
         this.uploadedFile$ = new Subject();
+        // same event as above but in DG-style
+        this.onFileUploaded = new Subject();
+        // HTML root of component
         this.root = ui.div();
+        // Validation object
+        this.validation = new Validation();
         this.visibleInput = ui.stringInput('Input file', this.initialText, null);
         this.hiddenInput = document.createElement('input');
         this.icon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());
+        this.isValid = new BehaviorSubject(true);
         this.draw();
+        this.isValid.subscribe((isValid) => {
+            if (isValid) {
+                this.visibleInput.input.classList.remove('error');
+                this.visibleInput.input.classList.add('success');
+                const newIcon = ui.iconFA('times', () => this.reset());
+                this.icon.replaceWith(newIcon);
+                this.icon = newIcon;
+            }
+            else {
+                this.visibleInput.input.classList.remove('success');
+                this.visibleInput.input.classList.add('error');
+                const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());
+                this.icon.replaceWith(newIcon);
+                this.icon = newIcon;
+            }
+        });
+        this.uploadedFile$.subscribe((file) => this.onFileUploaded.next(file));
         if (onValueChanged)
             this.uploadedFile$.subscribe((newValue) => onValueChanged(newValue));
     }
@@ -32,39 +56,31 @@ export class FileInput {
         const createFileArea = () => {
             this.visibleInput.input.readOnly = true;
             this.visibleInput.input.classList.add('default');
-            const handleFiles = (files) => {
+            const handleFiles = (files) => __awaiter(this, void 0, void 0, function* () {
                 if (!files || !files.length) {
                     this.uploadedFile$.next(null);
                     return;
                 }
                 if (files.length > 1) {
-                    this.visibleInput.input.classList.remove('success');
-                    this.visibleInput.input.classList.add('error');
-                    const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());
-                    this.icon.replaceWith(newIcon);
-                    this.icon = newIcon;
+                    this.isValid.next(false);
                     throw new Error('Please specify single input file');
                 }
                 this.visibleInput.value = files[0].name;
                 if (files[0].type !== this.fileType) {
-                    this.visibleInput.input.classList.remove('success');
-                    this.visibleInput.input.classList.add('error');
-                    const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());
-                    this.icon.replaceWith(newIcon);
-                    this.icon = newIcon;
+                    this.isValid.next(false);
                     throw new Error('File type is not supported');
                 }
-                this.visibleInput.input.classList.add('success');
-                const newIcon = ui.iconFA('times', () => this.reset());
-                this.icon.replaceWith(newIcon);
-                this.icon = newIcon;
-                this.uploadedFile$.next(files[0]);
-            };
+                this.isValid.next(yield this.validation.validate(files[0]));
+                if (this.isValid.value)
+                    this.uploadedFile$.next(files[0]);
+                else
+                    this.uploadedFile$.next(null);
+            });
             this.visibleInput.root.classList.add('cv-drop-area');
             this.visibleInput.root.style.width = '100%';
             // hidden input to handle file dialog
             this.hiddenInput.type = 'file';
-            this.hiddenInput.addEventListener('change', () => handleFiles(this.hiddenInput.files), false);
+            this.hiddenInput.addEventListener('change', () => __awaiter(this, void 0, void 0, function* () { return yield handleFiles(this.hiddenInput.files); }), false);
             // Prevent default drag behaviors
             ['dragenter', 'dragover', 'dragleave', 'drop'].forEach((eventName) => {
                 this.visibleInput.input.addEventListener(eventName, (e) => {
@@ -114,4 +130,4 @@ export class FileInput {
         ui.empty(this.root);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-input.js","sourceRoot":"","sources":["file-input.ts"],"names":[],"mappings":"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","sourcesContent":["import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport {Subject} from 'rxjs';\nimport '../../css/shared-components.css';\n\nexport const EXCEL_BLOB_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\n\nexport class FileInput {\n  // events to emit\n  public uploadedFile$ = new Subject<File | null>();\n\n  public root = ui.div();\n\n  private visibleInput = ui.stringInput('Input file', this.initialText, null);\n  private hiddenInput = document.createElement('input');\n  private icon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());\n\n  constructor(\n    public initialText = 'Drag-n-drop here',\n    public initialValue: File | null = null,\n    public onValueChanged: Function | null = null,\n    public fileType = EXCEL_BLOB_TYPE\n  ) {\n    this.draw();\n\n    if (onValueChanged)\n      this.uploadedFile$.subscribe((newValue: any) => onValueChanged(newValue));\n  }\n\n  private draw() {\n    this.clear();\n\n    const createFileArea = () => {\n      (this.visibleInput.input as HTMLInputElement).readOnly = true;\n      this.visibleInput.input.classList.add('default');\n\n      const handleFiles = (files: FileList | null) => {\n        if (!files || !files.length) {\n          this.uploadedFile$.next(null);\n          return;\n        }\n\n        if (files.length > 1) {\n          this.visibleInput.input.classList.remove('success');\n          this.visibleInput.input.classList.add('error');\n          const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());\n          this.icon.replaceWith(newIcon);\n          this.icon = newIcon;\n          throw new Error('Please specify single input file');\n        }\n\n        this.visibleInput.value = files[0].name;\n        if (files[0].type !== this.fileType) {\n          this.visibleInput.input.classList.remove('success');\n          this.visibleInput.input.classList.add('error');\n          const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());\n          this.icon.replaceWith(newIcon);\n          this.icon = newIcon;\n          throw new Error('File type is not supported');\n        }\n\n        this.visibleInput.input.classList.add('success');\n        const newIcon = ui.iconFA('times', () => this.reset());\n        this.icon.replaceWith(newIcon);\n        this.icon = newIcon;\n        this.uploadedFile$.next(files[0]);\n      };\n\n      this.visibleInput.root.classList.add('cv-drop-area');\n      this.visibleInput.root.style.width = '100%';\n\n      // hidden input to handle file dialog\n\n      this.hiddenInput.type = 'file';\n      this.hiddenInput.addEventListener('change', () => handleFiles(this.hiddenInput.files), false);\n\n      // Prevent default drag behaviors\n      ['dragenter', 'dragover', 'dragleave', 'drop'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, (e) => {\n          e.preventDefault();\n          e.stopPropagation();\n        }, false);\n      });\n\n      ['dragenter', 'dragover'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, () => {\n          this.visibleInput.input.classList.add('drag-n-dropping');\n        }, false);\n      });\n\n      ['dragleave', 'drop'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, () => {\n          this.visibleInput.input.classList.remove('drag-n-dropping');\n        }, false);\n      });\n\n      // Handle dropped files\n      this.visibleInput.input.addEventListener('drop', async (e: DragEvent) => {\n        const dt = e.dataTransfer;\n        const files = dt!.files;\n        handleFiles(files);\n      }, false);\n\n      // Pass clicks to hidden file input\n      this.visibleInput.input.addEventListener('click', () => this.hiddenInput.click(), false);\n      this.visibleInput.root.append(ui.div(this.icon, 'icon'));\n\n      return this.visibleInput;\n    };\n\n    ['drag', 'dragenter'].forEach((eventName) => {\n      document.getElementsByClassName('layout-workarea')[0].addEventListener(eventName, (e) => {\n        e.stopPropagation();\n      }, false);\n    });\n\n    this.root.style.display = 'flex';\n    this.root.append(createFileArea().root);\n  }\n\n  private reset() {\n    this.visibleInput.input.classList.value = 'ui-input-editor default';\n    const newIcon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());\n    this.icon.replaceWith(newIcon);\n    this.icon = newIcon;\n    this.visibleInput.value = 'Drag-n-drop here';\n    this.hiddenInput.value = '';\n    this.uploadedFile$.next(null);\n  }\n\n  private clear() {\n    ui.empty(this.root);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-input.js","sourceRoot":"","sources":["file-input.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport {BehaviorSubject, Subject} from 'rxjs';\nimport '../../css/shared-components.css';\nimport Validation from '../validation';\n\nexport const EXCEL_BLOB_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\n\nexport class FileInput {\n  // events to emit\n  public uploadedFile$ = new Subject<File | null>();\n  // same event as above but in DG-style\n  public onFileUploaded = new Subject<File | null>();\n  // HTML root of component\n  public root = ui.div();\n  // Validation object\n  public validation = new Validation<File>();\n\n  private visibleInput = ui.stringInput('Input file', this.initialText, null);\n  private hiddenInput = document.createElement('input');\n  private icon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());\n\n  private isValid = new BehaviorSubject<boolean>(true);\n\n  constructor(\n    public initialText = 'Drag-n-drop here',\n    public initialValue: File | null = null,\n    public onValueChanged: Function | null = null,\n    public fileType = EXCEL_BLOB_TYPE\n  ) {\n    this.draw();\n\n    this.isValid.subscribe((isValid) => {\n      if (isValid) {\n        this.visibleInput.input.classList.remove('error');\n        this.visibleInput.input.classList.add('success');\n        const newIcon = ui.iconFA('times', () => this.reset());\n        this.icon.replaceWith(newIcon);\n        this.icon = newIcon;\n      } else {\n        this.visibleInput.input.classList.remove('success');\n        this.visibleInput.input.classList.add('error');\n        const newIcon = ui.iconFA('redo', () => this.hiddenInput.click());\n        this.icon.replaceWith(newIcon);\n        this.icon = newIcon;\n      }\n    });\n\n    this.uploadedFile$.subscribe((file) => this.onFileUploaded.next(file));\n\n    if (onValueChanged)\n      this.uploadedFile$.subscribe((newValue: any) => onValueChanged(newValue));\n  }\n\n  private draw() {\n    this.clear();\n\n    const createFileArea = () => {\n      (this.visibleInput.input as HTMLInputElement).readOnly = true;\n      this.visibleInput.input.classList.add('default');\n\n      const handleFiles = async (files: FileList | null) => {\n        if (!files || !files.length) {\n          this.uploadedFile$.next(null);\n          return;\n        }\n\n        if (files.length > 1) {\n          this.isValid.next(false);\n          throw new Error('Please specify single input file');\n        }\n\n        this.visibleInput.value = files[0].name;\n        if (files[0].type !== this.fileType) {\n          this.isValid.next(false);\n          throw new Error('File type is not supported');\n        }\n\n        this.isValid.next(await this.validation.validate(files[0]));\n\n        if (this.isValid.value)\n          this.uploadedFile$.next(files[0]);\n        else\n          this.uploadedFile$.next(null);\n      };\n\n      this.visibleInput.root.classList.add('cv-drop-area');\n      this.visibleInput.root.style.width = '100%';\n\n      // hidden input to handle file dialog\n\n      this.hiddenInput.type = 'file';\n      this.hiddenInput.addEventListener('change', async () => await handleFiles(this.hiddenInput.files), false);\n\n      // Prevent default drag behaviors\n      ['dragenter', 'dragover', 'dragleave', 'drop'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, (e) => {\n          e.preventDefault();\n          e.stopPropagation();\n        }, false);\n      });\n\n      ['dragenter', 'dragover'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, () => {\n          this.visibleInput.input.classList.add('drag-n-dropping');\n        }, false);\n      });\n\n      ['dragleave', 'drop'].forEach((eventName) => {\n        this.visibleInput.input.addEventListener(eventName, () => {\n          this.visibleInput.input.classList.remove('drag-n-dropping');\n        }, false);\n      });\n\n      // Handle dropped files\n      this.visibleInput.input.addEventListener('drop', async (e: DragEvent) => {\n        const dt = e.dataTransfer;\n        const files = dt!.files;\n        handleFiles(files);\n      }, false);\n\n      // Pass clicks to hidden file input\n      this.visibleInput.input.addEventListener('click', () => this.hiddenInput.click(), false);\n      this.visibleInput.root.append(ui.div(this.icon, 'icon'));\n\n      return this.visibleInput;\n    };\n\n    ['drag', 'dragenter'].forEach((eventName) => {\n      document.getElementsByClassName('layout-workarea')[0].addEventListener(eventName, (e) => {\n        e.stopPropagation();\n      }, false);\n    });\n\n    this.root.style.display = 'flex';\n    this.root.append(createFileArea().root);\n  }\n\n  private reset() {\n    this.visibleInput.input.classList.value = 'ui-input-editor default';\n    const newIcon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());\n    this.icon.replaceWith(newIcon);\n    this.icon = newIcon;\n    this.visibleInput.value = 'Drag-n-drop here';\n    this.hiddenInput.value = '';\n    this.uploadedFile$.next(null);\n  }\n\n  private clear() {\n    ui.empty(this.root);\n  }\n}\n"]}

package/src/validation.d.ts

@@ -0,0 +1,56 @@
+import ExcelJS from 'exceljs';
+declare type ValidationSuccess = {
+    isValid: true;
+    chainedFuncs?: ValidatingFunc[];
+    result?: any;
+};
+declare type ValidationFailure = {
+    isValid: false;
+    caption: string;
+    content: HTMLElement | string;
+};
+declare type ValidationResult = ValidationSuccess | ValidationFailure;
+export declare type ValidatingFunc = ((arg: any) => Promise<ValidationResult>);
+declare type InitialValidatingFunc<InitialArgType> = ((arg: InitialArgType) => Promise<ValidationResult>);
+declare class Validation<InitialArgType> {
+    validators: InitialValidatingFunc<InitialArgType>[];
+    constructor(validators?: InitialValidatingFunc<InitialArgType>[]);
+    validate(initialArg: InitialArgType): Promise<boolean>;
+}
+export declare namespace v8n {
+    const isSheetExist: (sheetName: string, chainedFuncs?: ValidatingFunc[]) => (importedWb: ExcelJS.Workbook) => Promise<{
+        isValid: boolean;
+        caption: string;
+        content: string;
+        chainedFuncs?: undefined;
+        result?: undefined;
+    } | {
+        isValid: true;
+        chainedFuncs: ValidatingFunc[] | undefined;
+        result: ExcelJS.Worksheet;
+        caption?: undefined;
+        content?: undefined;
+    }>;
+    const isColumnExist: (columnName: string, chainedFuncs?: ValidatingFunc[]) => (sheet: ExcelJS.Worksheet) => Promise<{
+        isValid: boolean;
+        caption: string;
+        content: string;
+        chainedFuncs?: undefined;
+    } | {
+        isValid: true;
+        chainedFuncs: ValidatingFunc[] | undefined;
+        caption?: undefined;
+        content?: undefined;
+    }>;
+    const isExcelParsed: (chainedFuncs?: ValidatingFunc[]) => (file: File) => Promise<{
+        isValid: true;
+        chainedFuncs: ValidatingFunc[] | undefined;
+        result: ExcelJS.Workbook;
+    } | {
+        isValid: boolean;
+        caption: string;
+        content: string;
+    }>;
+}
+export default Validation;
+//# sourceMappingURL=validation.d.ts.map

package/src/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["validation.ts"],"names":[],"mappings":"AAKA,OAAO,OAAO,MAAM,SAAS,CAAC;AAE9B,aAAK,iBAAiB,GAAG;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAC,CAAC;AACxF,aAAK,iBAAiB,GAAG;IAAC,OAAO,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAA;CAAC,CAAC;AAC1F,aAAK,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAC9D,oBAAY,cAAc,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC;AACvE,aAAK,qBAAqB,CAAC,cAAc,IAAI,CAAC,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAElG,cAAM,UAAU,CAAC,cAAc;IAGpB,UAAU,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAAE;gBAAnD,UAAU,GAAE,qBAAqB,CAAC,cAAc,CAAC,EAAO;IAKpD,QAAQ,CAAC,UAAU,EAAE,cAAc;CAkFjD;AAED,yBAAiB,GAAG,CAAC;IACZ,MAAM,YAAY,cAAe,MAAM,iBAAiB,cAAc,EAAE,kBAAwB,QAAQ,QAAQ;;;;;;;;;;;;MAiBtH,CAAC;IAEK,MAAM,aAAa,eAAgB,MAAM,iBAAiB,cAAc,EAAE,aAAmB,QAAQ,SAAS;;;;;;;;;;MAkBpH,CAAC;IAEK,MAAM,aAAa,kBAAmB,cAAc,EAAE,YAAkB,IAAI;;;;;;;;MAmBlF,CAAC;CACH;AAED,eAAe,UAAU,CAAC"}

package/src/validation.js

@@ -0,0 +1,152 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import $ from 'cash-dom';
+import ExcelJS from 'exceljs';
+class Validation {
+    constructor(
+    // Validation functions to be stored and applied
+    validators = []) {
+        this.validators = validators;
+    }
+    validate(initialArg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const failedValidations = [];
+            const checkCustomValidators = (validators, result) => __awaiter(this, void 0, void 0, function* () {
+                for (const validator of validators) {
+                    const validationRes = yield validator(result);
+                    if (!validationRes.isValid)
+                        failedValidations.push(validationRes);
+                    else if (validationRes.chainedFuncs)
+                        yield checkCustomValidators(validationRes.chainedFuncs, validationRes.result);
+                }
+            });
+            for (const validator of this.validators) {
+                const validationRes = yield validator(initialArg);
+                if (!validationRes.isValid)
+                    failedValidations.push(validationRes);
+                else if (validationRes.chainedFuncs)
+                    yield checkCustomValidators(validationRes.chainedFuncs, validationRes.result);
+            }
+            if (failedValidations.length == 0)
+                return true;
+            const wizard = new DG.Wizard({ title: 'Data validation failed' });
+            failedValidations.forEach((validation) => {
+                wizard.page({
+                    caption: validation.caption,
+                    root: (validation.content instanceof HTMLElement ? validation.content : ui.markdown(validation.content)),
+                });
+            });
+            wizard.onOK(() => { });
+            const btnCancel = wizard.getButton('CANCEL');
+            const btnBack = wizard.getButton('<<');
+            const btnNext = wizard.getButton('>>');
+            const btnOk = wizard.getButton('OK');
+            const pagesLength = wizard.pages.length;
+            const stepCounter = ui.divText('1/' + pagesLength);
+            stepCounter.style.position = 'absolute';
+            stepCounter.style.left = '12px';
+            stepCounter.style.color = 'var(--grey-5)';
+            wizard.captionHost.style.fontSize = '20px';
+            wizard.captionHost.style.fontWeight = '400';
+            wizard.captionHost.style.margin = '6px 0';
+            $(wizard.root).find('.d4-command-bar').append(stepCounter);
+            $(btnBack).html('BACK');
+            $(btnNext).html('NEXT');
+            $(btnOk).addClass('disabled');
+            btnCancel.style.display = 'none';
+            btnBack.addEventListener('click', () => {
+                const curIndex = wizard.pageIndex + 1;
+                const pageIndex = wizard.pages.length;
+                wizard.captionHost.style.fontSize = '20px';
+                wizard.captionHost.style.fontWeight = '400';
+                wizard.captionHost.style.margin = '6px 0';
+                if (!wizard.completable)
+                    $(btnOk).addClass('disabled');
+                stepCounter.textContent = curIndex + '/' + pageIndex;
+            });
+            btnNext.addEventListener('click', () => {
+                const curIndex = wizard.pageIndex + 1;
+                const pageIndex = wizard.pages.length;
+                wizard.captionHost.style.fontSize = '20px';
+                wizard.captionHost.style.fontWeight = '400';
+                wizard.captionHost.style.margin = '6px 0';
+                if (wizard.completable)
+                    $(btnOk).removeClass('disabled');
+                stepCounter.textContent = curIndex + '/' + pageIndex;
+            });
+            wizard.show();
+            return false;
+        });
+    }
+}
+export var v8n;
+(function (v8n) {
+    v8n.isSheetExist = (sheetName, chainedFuncs) => (importedWb) => __awaiter(this, void 0, void 0, function* () {
+        const datasetWs = importedWb.worksheets.find((ws) => ws.name === sheetName);
+        if (!datasetWs) {
+            return {
+                isValid: false,
+                caption: `Sheet named '${sheetName}' is not found`,
+                content: `Sheet name should be exactly \`${sheetName}\` to be parsed. 
+\n   
+Please double-check:
+- No extra spaces are in the sheet name
+- Capitalization is the same as in the template
+\n
+${importedWb.worksheets.length > 0 ? `Found sheets: \`${importedWb.worksheets.map((ws) => ws.name).join('`,`')}\`` : `No columns have found.`} 
+        `
+            };
+        }
+        return { isValid: true, chainedFuncs, result: datasetWs };
+    });
+    v8n.isColumnExist = (columnName, chainedFuncs) => (sheet) => __awaiter(this, void 0, void 0, function* () {
+        const vals = sheet.getRow(1).values;
+        if (!vals.includes(columnName)) {
+            return {
+                isValid: false,
+                caption: `No column "${columnName}" in "${sheet.name}" sheet`,
+                content: `Column name should be exactly \`${columnName}\` to be parsed. 
+\n
+Please double-check:
+- Column names are in the first row of the sheet
+- No extra spaces are in the cell
+- Capitalization is the same as in the template
+\n
+${vals.length > 0 ? `Found columns: \`${vals.filter((val) => val !== '').join('`,`')}\`` : `No columns have found.`} 
+        `
+            };
+        }
+        return { isValid: true, chainedFuncs };
+    });
+    v8n.isExcelParsed = (chainedFuncs) => (file) => __awaiter(this, void 0, void 0, function* () {
+        const importedWb = new ExcelJS.Workbook();
+        return importedWb.xlsx.load(yield file.arrayBuffer())
+            .then((workbook) => __awaiter(this, void 0, void 0, function* () {
+            return { isValid: true, chainedFuncs, result: workbook };
+        }))
+            .catch(() => {
+            return {
+                isValid: false,
+                caption: 'File is failed to parse',
+                content: `Please make sure:
+- XLSX format is used (not XLS or XLSM)
+- File should not be corrupted
+\n
+XLS could be converted to XLSX using Excel's export functionality. \n
+If the file is corrupted, it will not open in Excel. 
+          `,
+            };
+        });
+    });
+})(v8n || (v8n = {}));
+export default Validation;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["validation.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport $ from 'cash-dom';\nimport ExcelJS from 'exceljs';\n\ntype ValidationSuccess = {isValid: true, chainedFuncs?: ValidatingFunc[], result?: any};\ntype ValidationFailure = {isValid: false, caption: string, content: HTMLElement | string};\ntype ValidationResult = ValidationSuccess | ValidationFailure;\nexport type ValidatingFunc = ((arg: any) => Promise<ValidationResult>);\ntype InitialValidatingFunc<InitialArgType> = ((arg: InitialArgType) => Promise<ValidationResult>);\n\nclass Validation<InitialArgType> {\n  constructor(\n    // Validation functions to be stored and applied\n    public validators: InitialValidatingFunc<InitialArgType>[] = []\n  ) {\n\n  }\n\n  public async validate(initialArg: InitialArgType) {\n    const failedValidations = [] as ValidationFailure[];\n    const checkCustomValidators = async (validators: ValidatingFunc[], result: any) => {\n      for (const validator of validators) {\n        const validationRes = await validator(result);\n        if (!validationRes.isValid)\n          failedValidations.push(validationRes);\n        else if (validationRes.chainedFuncs) await checkCustomValidators(validationRes.chainedFuncs, validationRes.result);\n      }\n    };\n\n    for (const validator of this.validators) {\n      const validationRes = await validator(initialArg);\n      if (!validationRes.isValid)\n        failedValidations.push(validationRes);\n      else if (validationRes.chainedFuncs) await checkCustomValidators(validationRes.chainedFuncs, validationRes.result);\n    }\n\n    if (failedValidations.length == 0) return true;\n\n    const wizard = new DG.Wizard({title: 'Data validation failed'});\n\n    failedValidations.forEach((validation) => {\n      wizard.page({\n        caption: validation.caption,\n        root: (validation.content instanceof HTMLElement ? validation.content : ui.markdown(validation.content)) as HTMLDivElement,\n      });\n    });\n    wizard.onOK(() => {});\n\n    const btnCancel = wizard.getButton('CANCEL');\n    const btnBack = wizard.getButton('<<');\n    const btnNext = wizard.getButton('>>');\n    const btnOk = wizard.getButton('OK');\n\n    const pagesLength = wizard.pages.length;\n\n    const stepCounter = ui.divText('1/'+pagesLength);\n    stepCounter.style.position = 'absolute';\n    stepCounter.style.left = '12px';\n    stepCounter.style.color = 'var(--grey-5)';\n\n    wizard.captionHost.style.fontSize = '20px';\n    wizard.captionHost.style.fontWeight = '400';\n    wizard.captionHost.style.margin = '6px 0';\n\n    $(wizard.root).find('.d4-command-bar').append(stepCounter);\n    $(btnBack).html('BACK');\n    $(btnNext).html('NEXT');\n    $(btnOk).addClass('disabled');\n    btnCancel.style.display = 'none';\n\n    btnBack.addEventListener('click', ()=>{\n      const curIndex = wizard.pageIndex+1;\n      const pageIndex = wizard.pages.length;\n\n      wizard.captionHost.style.fontSize = '20px';\n      wizard.captionHost.style.fontWeight = '400';\n      wizard.captionHost.style.margin = '6px 0';\n\n      if (!wizard.completable)\n        $(btnOk).addClass('disabled');\n\n      stepCounter.textContent = curIndex+'/'+pageIndex;\n    });\n\n    btnNext.addEventListener('click', ()=>{\n      const curIndex = wizard.pageIndex+1;\n      const pageIndex = wizard.pages.length;\n\n      wizard.captionHost.style.fontSize = '20px';\n      wizard.captionHost.style.fontWeight = '400';\n      wizard.captionHost.style.margin = '6px 0';\n\n      if (wizard.completable)\n        $(btnOk).removeClass('disabled');\n      stepCounter.textContent = curIndex+'/'+pageIndex;\n    });\n\n    wizard.show();\n    return false;\n  }\n}\n\nexport namespace v8n {\n  export const isSheetExist = (sheetName: string, chainedFuncs?: ValidatingFunc[]) => async (importedWb: ExcelJS.Workbook) => {\n    const datasetWs = importedWb.worksheets.find((ws) => ws.name === sheetName);\n    if (!datasetWs) {\n      return {\n        isValid: false,\n        caption: `Sheet named '${sheetName}' is not found`,\n        content: `Sheet name should be exactly \\`${sheetName}\\` to be parsed. \n\\n   \nPlease double-check:\n- No extra spaces are in the sheet name\n- Capitalization is the same as in the template\n\\n\n${importedWb.worksheets.length > 0 ? `Found sheets: \\`${importedWb.worksheets.map((ws) => ws.name).join('`,`')}\\``: `No columns have found.`} \n        `\n      };\n    }\n    return {isValid: true as true, chainedFuncs, result: datasetWs};\n  };\n\n  export const isColumnExist = (columnName: string, chainedFuncs?: ValidatingFunc[]) => async (sheet: ExcelJS.Worksheet) => {\n    const vals = sheet.getRow(1).values as ExcelJS.CellValue[];\n    if (!vals.includes(columnName)) {\n      return {\n        isValid: false,\n        caption: `No column \"${columnName}\" in \"${sheet.name}\" sheet`,\n        content: `Column name should be exactly \\`${columnName}\\` to be parsed. \n\\n\nPlease double-check:\n- Column names are in the first row of the sheet\n- No extra spaces are in the cell\n- Capitalization is the same as in the template\n\\n\n${vals.length > 0 ? `Found columns: \\`${vals.filter((val) => val !== '').join('`,`')}\\``: `No columns have found.`} \n        `\n      };\n    }\n    return {isValid: true as true, chainedFuncs};\n  };\n\n  export const isExcelParsed = (chainedFuncs?: ValidatingFunc[]) => async (file: File) => {\n    const importedWb = new ExcelJS.Workbook();\n    return importedWb.xlsx.load(await file.arrayBuffer())\n      .then(async (workbook) => {\n        return {isValid: true as true, chainedFuncs, result: workbook};\n      })\n      .catch(() => {\n        return {\n          isValid: false,\n          caption: 'File is failed to parse',\n          content: `Please make sure:\n- XLSX format is used (not XLS or XLSM)\n- File should not be corrupted\n\\n\nXLS could be converted to XLSX using Excel's export functionality. \\n\nIf the file is corrupted, it will not open in Excel. \n          `,\n        };\n      });\n  };\n}\n\nexport default Validation;\n"]}