@datagrok-libraries/utils 1.2.0 → 1.3.0

package/css/shared-components.css

@@ -0,0 +1,27 @@
+.drop-area {
+  position: relative;
+}
+
+.ui-form-condensed .drop-area .icon {
+  position: absolute;
+  top: 25px;
+  right: 10px;
+}
+
+.drop-area .default {
+  color: var(--grey-2);
+}
+
+.drop-area .drag-n-dropping {
+  background-color: var(--steel-1);
+  border: 1px dashed var(--blue-1);
+  color: var(--grey-3);
+}
+
+.drop-area .error {
+  color: var(--red-3);
+}
+
+.drop-area .success {
+  color: var(--grey-6);
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public"
   },
   "fullName": "Utils",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Common utilities",
   "dependencies": {
     "@types/node": "^14.14.37",
@@ -14,6 +14,7 @@
     "exceljs": "^4.3.0",
     "html2canvas": "^1.4.1",
     "node-fetch": "^2.6.0",
+    "rxjs": "^7.5.6",
     "wu": "latest"
   },
   "devDependencies": {

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

@@ -0,0 +1,19 @@
+import { Subject } from 'rxjs';
+import '../../css/shared-components.css';
+export declare const EXCEL_BLOB_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+export declare class FileInput {
+    initialText: string;
+    initialValue: File | null;
+    onValueChanged: Function | null;
+    fileType: string;
+    uploadedFile$: Subject<File | null>;
+    root: HTMLDivElement;
+    private visibleInput;
+    private hiddenInput;
+    private icon;
+    constructor(initialText?: string, initialValue?: File | null, onValueChanged?: Function | null, fileType?: string);
+    private draw;
+    private reset;
+    private clear;
+}
+//# sourceMappingURL=file-input.d.ts.map

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

@@ -0,0 +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;IA0FZ,OAAO,CAAC,KAAK;IASb,OAAO,CAAC,KAAK;CAGd"}

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

@@ -0,0 +1,116 @@
+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 { Subject } from 'rxjs';
+import '../../css/shared-components.css';
+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) {
+        this.initialText = initialText;
+        this.initialValue = initialValue;
+        this.onValueChanged = onValueChanged;
+        this.fileType = fileType;
+        // events to emit
+        this.uploadedFile$ = new Subject();
+        this.root = ui.div();
+        this.visibleInput = ui.stringInput('Input file', this.initialText, null);
+        this.hiddenInput = document.createElement('input');
+        this.icon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());
+        this.draw();
+        if (onValueChanged)
+            this.uploadedFile$.subscribe(() => this.onValueChanged);
+    }
+    draw() {
+        this.clear();
+        const createFileArea = () => {
+            this.visibleInput.input.readOnly = true;
+            this.visibleInput.input.classList.add('default');
+            const handleFiles = (files) => {
+                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;
+                    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;
+                    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.visibleInput.root.classList.add('drop-area');
+            this.visibleInput.root.style.width = '100%';
+            // hidden input to handle file dialog
+            this.hiddenInput.type = 'file';
+            this.hiddenInput.onchange = (e) => {
+                //@ts-ignore
+                const files = e.target.files;
+                handleFiles(files);
+            };
+            // Prevent default drag behaviors
+            ['dragenter', 'dragover', 'dragleave', 'drop'].forEach((eventName) => {
+                this.visibleInput.input.addEventListener(eventName, (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                }, false);
+            });
+            ['dragenter', 'dragover'].forEach((eventName) => {
+                this.visibleInput.input.addEventListener(eventName, () => {
+                    this.visibleInput.input.classList.add('drag-n-dropping');
+                }, false);
+            });
+            ['dragleave', 'drop'].forEach((eventName) => {
+                this.visibleInput.input.addEventListener(eventName, () => {
+                    this.visibleInput.input.classList.remove('drag-n-dropping');
+                }, false);
+            });
+            // Handle dropped files
+            this.visibleInput.input.addEventListener('drop', (e) => __awaiter(this, void 0, void 0, function* () {
+                const dt = e.dataTransfer;
+                const files = dt.files;
+                handleFiles(files);
+            }), false);
+            // Pass clicks to hidden file input
+            this.visibleInput.input.addEventListener('click', () => this.hiddenInput.click(), false);
+            this.visibleInput.root.append(ui.div(this.icon, 'icon'));
+            return this.visibleInput;
+        };
+        ['drag', 'dragenter'].forEach((eventName) => {
+            document.getElementsByClassName('layout-workarea')[0].addEventListener(eventName, (e) => {
+                e.stopPropagation();
+            }, false);
+        });
+        this.root.style.display = 'flex';
+        this.root.append(createFileArea().root);
+    }
+    reset() {
+        this.visibleInput.input.classList.value = 'ui-input-editor default';
+        const newIcon = ui.iconFA('cloud-upload', () => this.hiddenInput.click());
+        this.icon.replaceWith(newIcon);
+        this.icon = newIcon;
+        this.visibleInput.value = this.initialText;
+        this.uploadedFile$.next(this.initialValue);
+    }
+    clear() {
+        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(() => this.onValueChanged);\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) => {\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('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.onchange = (e) => {\n        //@ts-ignore\n        const files: FileList = e.target.files;\n        handleFiles(files);\n      };\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 = this.initialText;\n    this.uploadedFile$.next(this.initialValue);\n  }\n\n  private clear() {\n    ui.empty(this.root);\n  }\n}\n"]}

package/src/shared-components/ui-utils.d.ts

@@ -0,0 +1,5 @@
+import { FileInput } from './file-input';
+export declare namespace UiUtils {
+    function fileInput(initialText?: string, initialValue?: File | null, onValueChanged?: Function | null, fileType?: string): FileInput;
+}
+//# sourceMappingURL=ui-utils.d.ts.map

package/src/shared-components/ui-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-utils.d.ts","sourceRoot":"","sources":["ui-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,SAAS,EAAC,MAAM,cAAc,CAAC;AAExD,yBAAiB,OAAO,CAAC;IACvB,SAAgB,SAAS,CACvB,WAAW,SAAqB,EAChC,YAAY,GAAE,IAAI,GAAG,IAAW,EAChC,cAAc,GAAE,QAAQ,GAAG,IAAW,EACtC,QAAQ,SAAkB,aAG3B;CACF"}

package/src/shared-components/ui-utils.js

@@ -0,0 +1,9 @@
+import { EXCEL_BLOB_TYPE, FileInput } from './file-input';
+export var UiUtils;
+(function (UiUtils) {
+    function fileInput(initialText = 'Drag-n-drop here', initialValue = null, onValueChanged = null, fileType = EXCEL_BLOB_TYPE) {
+        return new FileInput(initialText, initialValue, onValueChanged, fileType);
+    }
+    UiUtils.fileInput = fileInput;
+})(UiUtils || (UiUtils = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidWktdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ1aS11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsZUFBZSxFQUFFLFNBQVMsRUFBQyxNQUFNLGNBQWMsQ0FBQztBQUV4RCxNQUFNLEtBQVcsT0FBTyxDQVN2QjtBQVRELFdBQWlCLE9BQU87SUFDdEIsU0FBZ0IsU0FBUyxDQUN2QixXQUFXLEdBQUcsa0JBQWtCLEVBQ2hDLGVBQTRCLElBQUksRUFDaEMsaUJBQWtDLElBQUksRUFDdEMsUUFBUSxHQUFHLGVBQWU7UUFFMUIsT0FBTyxJQUFJLFNBQVMsQ0FBQyxXQUFXLEVBQUUsWUFBWSxFQUFFLGNBQWMsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUM1RSxDQUFDO0lBUGUsaUJBQVMsWUFPeEIsQ0FBQTtBQUNILENBQUMsRUFUZ0IsT0FBTyxLQUFQLE9BQU8sUUFTdkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0VYQ0VMX0JMT0JfVFlQRSwgRmlsZUlucHV0fSBmcm9tICcuL2ZpbGUtaW5wdXQnO1xuXG5leHBvcnQgbmFtZXNwYWNlIFVpVXRpbHMge1xuICBleHBvcnQgZnVuY3Rpb24gZmlsZUlucHV0KFxuICAgIGluaXRpYWxUZXh0ID0gJ0RyYWctbi1kcm9wIGhlcmUnLFxuICAgIGluaXRpYWxWYWx1ZTogRmlsZSB8IG51bGwgPSBudWxsLFxuICAgIG9uVmFsdWVDaGFuZ2VkOiBGdW5jdGlvbiB8IG51bGwgPSBudWxsLFxuICAgIGZpbGVUeXBlID0gRVhDRUxfQkxPQl9UWVBFXG4gICkge1xuICAgIHJldHVybiBuZXcgRmlsZUlucHV0KGluaXRpYWxUZXh0LCBpbml0aWFsVmFsdWUsIG9uVmFsdWVDaGFuZ2VkLCBmaWxlVHlwZSk7XG4gIH1cbn1cbiJdfQ==