@datagrok-libraries/utils 0.2.9 → 0.3.9

package/.eslintrc.json

@@ -34,6 +34,7 @@
           "error",
           "1tbs",
           { "allowSingleLine": true }
-        ]
+        ],
+        "no-unused-vars": "off"
     }
 }

package/package.json

@@ -4,25 +4,26 @@
     "access": "public"
   },
   "fullName": "Utils",
-  "version": "0.2.9",
+  "version": "0.3.9",
   "description": "Common utilities",
   "dependencies": {
-    "cash-dom": "latest",
     "@types/node": "^14.14.37",
+    "cash-dom": "latest",
     "datagrok-api": "^0.148.3",
     "dts-bundle": "^0.7.3",
+    "exceljs": "^4.3.0",
     "node-fetch": "^2.6.0",
     "rxjs": "^7.4.0",
     "wu": "latest"
   },
   "devDependencies": {
+    "@types/wu": "latest",
     "@typescript-eslint/eslint-plugin": "^5.11.0",
     "@typescript-eslint/parser": "^5.11.0",
     "eslint": "^8.8.0",
     "eslint-config-google": "^0.14.0",
     "ts-loader": "^9.2.6",
-    "typescript": "^4.2.3",
-    "@types/wu": "latest"
+    "typescript": "^4.2.3"
   },
   "scripts": {
     "link": "npm link",

package/src/computation-view/common/inject-tokens.d.ts

@@ -0,0 +1,10 @@
+export declare const tokens: {
+    readonly stateService: "stateService";
+    readonly historyService: "historyService";
+    readonly exportService: "exportService";
+    readonly inputPanel: "inputPanel";
+    readonly outputPanel: "outputPanel";
+    readonly exportPanel: "exportPanel";
+    readonly historyPanel: "historyPanel";
+};
+//# sourceMappingURL=inject-tokens.d.ts.map

package/src/computation-view/common/inject-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-tokens.d.ts","sourceRoot":"","sources":["inject-tokens.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;CAST,CAAC"}

package/src/computation-view/common/inject-tokens.js

@@ -0,0 +1,10 @@
+export const tokens = {
+    stateService: 'stateService',
+    historyService: 'historyService',
+    exportService: 'exportService',
+    inputPanel: 'inputPanel',
+    outputPanel: 'outputPanel',
+    exportPanel: 'exportPanel',
+    historyPanel: 'historyPanel',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0LXRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImluamVjdC10b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHO0lBQ3BCLFlBQVksRUFBRSxjQUFjO0lBQzVCLGNBQWMsRUFBRSxnQkFBZ0I7SUFDaEMsYUFBYSxFQUFFLGVBQWU7SUFFOUIsVUFBVSxFQUFFLFlBQVk7SUFDeEIsV0FBVyxFQUFFLGFBQWE7SUFDMUIsV0FBVyxFQUFFLGFBQWE7SUFDMUIsWUFBWSxFQUFFLGNBQWM7Q0FDcEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCB0b2tlbnMgPSB7XG4gIHN0YXRlU2VydmljZTogJ3N0YXRlU2VydmljZScsXG4gIGhpc3RvcnlTZXJ2aWNlOiAnaGlzdG9yeVNlcnZpY2UnLFxuICBleHBvcnRTZXJ2aWNlOiAnZXhwb3J0U2VydmljZScsXG5cbiAgaW5wdXRQYW5lbDogJ2lucHV0UGFuZWwnLFxuICBvdXRwdXRQYW5lbDogJ291dHB1dFBhbmVsJyxcbiAgZXhwb3J0UGFuZWw6ICdleHBvcnRQYW5lbCcsXG4gIGhpc3RvcnlQYW5lbDogJ2hpc3RvcnlQYW5lbCcsXG59IGFzIGNvbnN0O1xuIl19

package/src/computation-view/common/service-interfaces.d.ts

@@ -0,0 +1,40 @@
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+export interface Component {
+    root: HTMLElement;
+    render(): void;
+}
+export interface ExportService {
+    get supportedExportFormats(): string[];
+    /** Override to provide custom file extensions for exported formats.
+     * These formats are available under the "Export" popup on the ribbon panel. */
+    get supportedExportExtensions(): Record<string, string>;
+    filename(format: string): string;
+    /** Override to provide custom export. */
+    export(format: string): Promise<Blob>;
+}
+export interface StateService {
+    /** Name of view */
+    name: string;
+    /** Function last call info */
+    lastCall: DG.FuncCall | null;
+    /** Main function of ComputationView. */
+    func: DG.Func | null;
+    /** The actual computation function. */
+    compute(call: DG.FuncCall): Promise<void>;
+    /** Maps inputs to parameters, computes, and maps output parameters to the UI. */
+    run(): Promise<void>;
+    /** Prepare func to run */
+    prepare(): void;
+    onComputationError: Subject<DG.FuncCall>;
+    onComputationCompleted: Subject<DG.FuncCall>;
+}
+export interface HistoricalRunService {
+    /** Saves the computation results to the historical results, returns its id. See also {@link loadRun}. */
+    saveRun(call: DG.FuncCall): Promise<string>;
+    /** Loads the specified historical results. See also {@link saveRun}. */
+    loadRun(runId: string): Promise<DG.FuncCall>;
+    /** Pulls functions' historical runs list */
+    pullRuns(): Promise<DG.FuncCall[]>;
+}
+//# sourceMappingURL=service-interfaces.d.ts.map

package/src/computation-view/common/service-interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-interfaces.d.ts","sourceRoot":"","sources":["service-interfaces.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAE7B,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,WAAW,CAAA;IAEjB,MAAM,IAAI,IAAI,CAAA;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,sBAAsB,IAAI,MAAM,EAAE,CAAA;IAEtC;mFAC+E;IAC/E,IAAI,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEvD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAEhC,yCAAyC;IACzC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED,MAAM,WAAW,YAAY;IAC3B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAA;IAEZ,8BAA8B;IAC9B,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,IAAI,CAAC;IAE7B,wCAAwC;IACxC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC;IAErB,uCAAuC;IACvC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C,iFAAiF;IACjF,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAErB,0BAA0B;IAC1B,OAAO,IAAI,IAAI,CAAC;IAEhB,kBAAkB,EAAE,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;IACzC,sBAAsB,EAAE,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,oBAAoB;IACnC,yGAAyG;IACzG,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE3C,wEAAwE;IACxE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAA;IAE5C,4CAA4C;IAC5C,QAAQ,IAAI,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAA;CACnC"}

package/src/computation-view/common/service-interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/computation-view.d.ts

@@ -0,0 +1,30 @@
+import * as DG from 'datagrok-api/dg';
+import { FunctionView } from '../function-view';
+import { Component, StateService } from './common/service-interfaces';
+/**
+ * Base class for handling Compute models (see https://github.com/datagrok-ai/public/blob/master/help/compute/compute.md).
+ * In most cases, the computation is a simple {@link Func}
+ * Extend it in cases where a behavior or UI not supported by the {@link FunctionView} is needed.
+ *
+ * It provides the following functionality out-of-the-box, where each section could be customized:
+ * - a structured way to represent input and output parameters: {@link parameters}
+ * - generic way to generate UI for inputs, outputs, and interactivity (running the model, etc)
+ *   - persisting historical results to the db (via {@link parameters})
+ * - export (to Excel and PDF): {@link export}
+ * - easy loading of historical runs
+ * - routing
+ * - entering the real, measured (as opposed to predicted) values manually
+ * - notifications for changing inputs, completion of computations, etc: {@link onInputChanged}
+ * */
+export declare class ComputationView extends FunctionView {
+    state: StateService;
+    inputPanel: Component;
+    outputPanel: Component;
+    exportButton: Component;
+    static inject: readonly ["stateService", "inputPanel", "outputPanel", "exportPanel"];
+    /** Not intented to be used directly in common case. Use {@link ComputationViewBuilder} instead. */
+    constructor(state: StateService, inputPanel: Component, outputPanel: Component, exportButton: Component);
+    /** Override to provide custom initialization. {@link onViewInitialized} gets fired after that. */
+    render(func: DG.Func): Promise<void>;
+}
+//# sourceMappingURL=computation-view.d.ts.map

package/src/computation-view/computation-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computation-view.d.ts","sourceRoot":"","sources":["computation-view.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAE,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAGpE;;;;;;;;;;;;;;KAcK;AACL,qBAAa,eAAgB,SAAQ,YAAY;IAUtC,KAAK,EAAE,YAAY;IACnB,UAAU,EAAE,SAAS;IACrB,WAAW,EAAE,SAAS;IACtB,YAAY,EAAE,SAAS;IAZhC,OAAc,MAAM,wEAKT;IAEX,mGAAmG;gBAE1F,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,SAAS,EACrB,WAAW,EAAE,SAAS,EACtB,YAAY,EAAE,SAAS;IAQhC,kGAAkG;IACrF,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAWlD"}

package/src/computation-view/computation-view.js

@@ -0,0 +1,61 @@
+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 { FunctionView } from '../function-view';
+import { tokens } from './common/inject-tokens';
+/**
+ * Base class for handling Compute models (see https://github.com/datagrok-ai/public/blob/master/help/compute/compute.md).
+ * In most cases, the computation is a simple {@link Func}
+ * Extend it in cases where a behavior or UI not supported by the {@link FunctionView} is needed.
+ *
+ * It provides the following functionality out-of-the-box, where each section could be customized:
+ * - a structured way to represent input and output parameters: {@link parameters}
+ * - generic way to generate UI for inputs, outputs, and interactivity (running the model, etc)
+ *   - persisting historical results to the db (via {@link parameters})
+ * - export (to Excel and PDF): {@link export}
+ * - easy loading of historical runs
+ * - routing
+ * - entering the real, measured (as opposed to predicted) values manually
+ * - notifications for changing inputs, completion of computations, etc: {@link onInputChanged}
+ * */
+export class ComputationView extends FunctionView {
+    /** Not intented to be used directly in common case. Use {@link ComputationViewBuilder} instead. */
+    constructor(state, inputPanel, outputPanel, exportButton) {
+        super(state.func);
+        this.state = state;
+        this.inputPanel = inputPanel;
+        this.outputPanel = outputPanel;
+        this.exportButton = exportButton;
+        if (this.state.func != null)
+            this.render(this.state.func);
+    }
+    /** Override to provide custom initialization. {@link onViewInitialized} gets fired after that. */
+    render(func) {
+        const _super = Object.create(null, {
+            init: { get: () => super.init }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state.func = func;
+            yield _super.init.call(this, this.state.func);
+            this.root.innerHTML = '';
+            this.root.append(ui.divH([this.inputPanel.root, this.outputPanel.root]));
+            this.setRibbonPanels([[
+                    this.exportButton.root,
+                ]]);
+        });
+    }
+}
+ComputationView.inject = [
+    tokens.stateService,
+    tokens.inputPanel,
+    tokens.outputPanel,
+    tokens.exportPanel,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/default-components/export-component.d.ts

@@ -0,0 +1,9 @@
+import { Component, ExportService } from '../common/service-interfaces';
+export declare class DefaultExportComponent implements Component {
+    private exportService;
+    root: HTMLElement;
+    static inject: readonly ["exportService"];
+    constructor(exportService: ExportService);
+    render(): void;
+}
+//# sourceMappingURL=export-component.d.ts.map

package/src/computation-view/default-components/export-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-component.d.ts","sourceRoot":"","sources":["export-component.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,SAAS,EAAE,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAGtE,qBAAa,sBAAuB,YAAW,SAAS;IAQpD,OAAO,CAAC,aAAa;IAPhB,IAAI,EAAE,WAAW,CAAY;IAEpC,OAAc,MAAM,6BAET;gBAGD,aAAa,EAAE,aAAa;IAKtC,MAAM,IAAI,IAAI;CAQf"}

package/src/computation-view/default-components/export-component.js

@@ -0,0 +1,26 @@
+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 { tokens } from '../common/inject-tokens';
+export class DefaultExportComponent {
+    constructor(exportService) {
+        this.exportService = exportService;
+        this.root = ui.div();
+        this.render();
+    }
+    render() {
+        this.root = ui.comboPopup(ui.icons.save(null, 'Export'), this.exportService.supportedExportFormats, (format) => __awaiter(this, void 0, void 0, function* () { return DG.Utils.download(this.exportService.filename(format), yield this.exportService.export(format)); }));
+    }
+}
+DefaultExportComponent.inject = [
+    tokens.exportService,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/default-components/historical-run-load-component.d.ts

@@ -0,0 +1,9 @@
+import { Component, HistoricalRunService } from '../common/service-interfaces';
+export declare class DefaultHistoricalRunComponent implements Component {
+    private historicalRunService;
+    root: HTMLElement;
+    static inject: readonly ["historyService"];
+    constructor(historicalRunService: HistoricalRunService);
+    render(): void;
+}
+//# sourceMappingURL=historical-run-load-component.d.ts.map

package/src/computation-view/default-components/historical-run-load-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historical-run-load-component.d.ts","sourceRoot":"","sources":["historical-run-load-component.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,SAAS,EAAE,oBAAoB,EAAC,MAAM,8BAA8B,CAAC;AAG7E,qBAAa,6BAA8B,YAAW,SAAS;IAOjD,OAAO,CAAC,oBAAoB;IANjC,IAAI,EAAE,WAAW,CAAY;IAEpC,OAAc,MAAM,8BAET;gBAES,oBAAoB,EAAE,oBAAoB;IAI9D,MAAM,IAAI,IAAI;CAcf"}

package/src/computation-view/default-components/historical-run-load-component.js

@@ -0,0 +1,37 @@
+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 { tokens } from '../common/inject-tokens';
+export class DefaultHistoricalRunComponent {
+    constructor(historicalRunService) {
+        this.historicalRunService = historicalRunService;
+        this.root = ui.div();
+        this.render();
+    }
+    render() {
+        this.root = ui.iconFA('history', () => {
+            this.historicalRunService.pullRuns().then((historicalRuns) => __awaiter(this, void 0, void 0, function* () {
+                const menu = DG.Menu.popup();
+                let i = 0;
+                for (const run of historicalRuns) {
+                    //@ts-ignore
+                    menu.item(`${run.func.friendlyName} — ${i}`, () => __awaiter(this, void 0, void 0, function* () { return this.historicalRunService.loadRun(run.id); }));
+                    i++;
+                }
+                menu.show();
+            }));
+        });
+    }
+}
+DefaultHistoricalRunComponent.inject = [
+    tokens.historyService,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/default-components/input-panel-component.d.ts

@@ -0,0 +1,14 @@
+import * as DG from 'datagrok-api/dg';
+import { Component, StateService } from '../common/service-interfaces';
+export declare class DefaultInputPanelComponent implements Component {
+    private state;
+    private loadRunsButton;
+    root: HTMLElement;
+    /** All inputs that are bound to fields */
+    inputFields: Record<string, DG.InputBase>;
+    static inject: readonly ["stateService", "historyPanel"];
+    constructor(state: StateService, loadRunsButton: Component);
+    render(): void;
+    renderRunSection(call: DG.FuncCall): HTMLElement;
+}
+//# sourceMappingURL=input-panel-component.d.ts.map

package/src/computation-view/default-components/input-panel-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-panel-component.d.ts","sourceRoot":"","sources":["input-panel-component.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,SAAS,EAAE,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAGrE,qBAAa,0BAA2B,YAAW,SAAS;IAYxD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,cAAc;IAZjB,IAAI,EAAE,WAAW,CAAY;IAEpC,0CAA0C;IACnC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,SAAS,CAAC,CAAM;IAEtD,OAAc,MAAM,4CAGT;gBAGD,KAAK,EAAE,YAAY,EACnB,cAAc,EAAE,SAAS;IAKnC,MAAM;IAIN,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,WAAW;CAWjD"}

package/src/computation-view/default-components/input-panel-component.js

@@ -0,0 +1,40 @@
+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 { tokens } from '../common/inject-tokens';
+export class DefaultInputPanelComponent {
+    constructor(state, loadRunsButton) {
+        this.state = state;
+        this.loadRunsButton = loadRunsButton;
+        this.root = ui.div();
+        /** All inputs that are bound to fields */
+        this.inputFields = {};
+        this.render();
+    }
+    render() {
+        this.root = ui.div([this.renderRunSection(this.state.lastCall)], 'ui-div');
+    }
+    renderRunSection(call) {
+        return ui.wait(() => __awaiter(this, void 0, void 0, function* () {
+            const runButton = ui.bigButton('Run', () => __awaiter(this, void 0, void 0, function* () {
+                yield this.state.run();
+            }));
+            const editor = ui.div([], 'ui-form');
+            const inputs = yield call.buildEditor(editor, { condensed: true });
+            editor.appendChild(ui.divH([ui.divV([this.loadRunsButton.root], { style: { 'justify-content': 'center' } }), runButton], { style: { 'justify-content': 'space-between' } }));
+            return ui.panel([editor]);
+        }));
+    }
+}
+DefaultInputPanelComponent.inject = [
+    tokens.stateService,
+    tokens.historyPanel,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/default-components/output-panel-component.d.ts

@@ -0,0 +1,9 @@
+import { Component, StateService } from '../common/service-interfaces';
+export declare class DefaultOutputPanelComponent implements Component {
+    private state;
+    root: HTMLElement;
+    static inject: readonly ["stateService"];
+    constructor(state: StateService);
+    render(): void;
+}
+//# sourceMappingURL=output-panel-component.d.ts.map

package/src/computation-view/default-components/output-panel-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-panel-component.d.ts","sourceRoot":"","sources":["output-panel-component.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAGrE,qBAAa,2BAA4B,YAAW,SAAS;IAQzD,OAAO,CAAC,KAAK;IAPR,IAAI,EAAE,WAAW,CAAc;IAEtC,OAAc,MAAM,4BAET;gBAGD,KAAK,EAAE,YAAY;IAK7B,MAAM,IAAI,IAAI;CAWf"}

package/src/computation-view/default-components/output-panel-component.js

@@ -0,0 +1,23 @@
+import * as ui from 'datagrok-api/ui';
+import { tokens } from '../common/inject-tokens';
+export class DefaultOutputPanelComponent {
+    constructor(state) {
+        this.state = state;
+        this.root = ui.div([]);
+        this.state.onComputationCompleted.subscribe(() => this.render());
+    }
+    render() {
+        var _a;
+        const outputs = (_a = this.state.lastCall) === null || _a === void 0 ? void 0 : _a.outputs;
+        console.log(Object.entries(outputs));
+        const panel = ui.accordion('Output data');
+        panel.addPane('Output data', () => {
+            return ui.divV(Object.entries(outputs).map(([key, val]) => ui.span([`${key}: `, `${val}`])));
+        });
+        this.root.replaceWith(panel.root);
+    }
+}
+DefaultOutputPanelComponent.inject = [
+    tokens.stateService,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/src/computation-view/default-services/export-service.d.ts

@@ -0,0 +1,16 @@
+import { ExportService, StateService } from '../common/service-interfaces';
+export declare class DefaultExportService implements ExportService {
+    private state;
+    static inject: readonly ["stateService"];
+    constructor(state: StateService);
+    filename(format: string): string;
+    /** Override to provide supported export formats.
+     * These formats are available under the "Export" popup on the ribbon panel. */
+    get supportedExportFormats(): string[];
+    /** Override to provide custom file extensions for exported formats.
+     * These formats are available under the "Export" popup on the ribbon panel. */
+    get supportedExportExtensions(): Record<string, string>;
+    /** Override to provide custom export. */
+    export(format: string): Promise<Blob>;
+}
+//# sourceMappingURL=export-service.d.ts.map

package/src/computation-view/default-services/export-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-service.d.ts","sourceRoot":"","sources":["export-service.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAyCzE,qBAAa,oBAAqB,YAAW,aAAa;IAMtD,OAAO,CAAC,KAAK;IALf,OAAc,MAAM,4BAET;gBAGD,KAAK,EAAE,YAAY;IAG7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIhC;mFAC+E;IAC/E,IAAI,sBAAsB,IAAI,MAAM,EAAE,CAIrC;IAED;mFAC+E;IAC/E,IAAI,yBAAyB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItD;IAED,yCAAyC;IACnC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA0D5C"}

package/src/computation-view/default-services/export-service.js

@@ -0,0 +1,116 @@
+/* eslint-disable valid-jsdoc */
+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 DG from 'datagrok-api/dg';
+import ExcelJS from 'exceljs';
+import { tokens } from '../common/inject-tokens';
+const getSheetName = (name, direction) => {
+    const idealName = `${direction} - ${name}`;
+    return (idealName.length > 31) ? name.substring(0, 32) : idealName;
+};
+var DIRECTION;
+(function (DIRECTION) {
+    DIRECTION["INPUT"] = "Input";
+    DIRECTION["OUTPUT"] = "Output";
+})(DIRECTION || (DIRECTION = {}));
+const scalarsToSheet = (sheet, scalars) => {
+    sheet.addRow(['Parameter', 'Value', 'Units']).font = { bold: true };
+    scalars.forEach((scalar) => {
+        sheet.addRow([scalar.caption, scalar.value, scalar.units]);
+    });
+    sheet.getColumn(1).width = Math.max(...scalars.map((scalar) => scalar.caption.toString().length), 'Parameter'.length) * 1.2;
+    sheet.getColumn(2).width = Math.max(...scalars.map((scalar) => scalar.value.toString().length), 'Value'.length) * 1.2;
+    sheet.getColumn(3).width = Math.max(...scalars.map((scalar) => scalar.units.toString().length), 'Units'.length) * 1.2;
+};
+const dfToSheet = (sheet, df) => {
+    sheet.addRow(df.columns.names()).font = { bold: true };
+    for (let i = 0; i < df.rowCount; i++)
+        sheet.addRow([...df.row(i).cells].map((cell) => cell.value));
+    for (let i = 0; i < df.columns.length; i++) {
+        sheet.getColumn(i + 1).width =
+            Math.max(...df.columns.byIndex(i).categories.map((category) => category.toString().length), df.columns.byIndex(i).name.length) * 1.2;
+    }
+};
+export class DefaultExportService {
+    constructor(state) {
+        this.state = state;
+    }
+    filename(format) {
+        return `${this.state.name} - ${new Date().toLocaleString()}.${this.supportedExportExtensions[format]}`;
+    }
+    /** Override to provide supported export formats.
+     * These formats are available under the "Export" popup on the ribbon panel. */
+    get supportedExportFormats() {
+        return [
+            'Excel',
+        ];
+    }
+    /** Override to provide custom file extensions for exported formats.
+     * These formats are available under the "Export" popup on the ribbon panel. */
+    get supportedExportExtensions() {
+        return {
+            'Excel': 'xlsx',
+        };
+    }
+    /** Override to provide custom export. */
+    export(format) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.state.func)
+                throw new Error(`No function is associated with view`);
+            const lastCall = this.state.lastCall;
+            if (!lastCall)
+                throw new Error(`Function was not called`);
+            if (format !== 'Excel')
+                throw new Error(`Format "${format}" is not supported.`);
+            const BLOB_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
+            const exportWorkbook = new ExcelJS.Workbook();
+            const isScalarType = (type) => (DG.TYPES_SCALAR.has(type));
+            const isDataFrame = (type) => (type === DG.TYPE.DATA_FRAME);
+            const dfInputs = this.state.func.inputs.filter((input) => isDataFrame(input.propertyType));
+            const scalarInputs = this.state.func.inputs.filter((input) => isScalarType(input.propertyType));
+            const dfOutputs = this.state.func.outputs.filter((output) => isDataFrame(output.propertyType));
+            const scalarOutputs = this.state.func.outputs.filter((output) => isScalarType(output.propertyType));
+            dfInputs.forEach((dfInput) => {
+                const visibleTitle = dfInput.options.caption || dfInput.name;
+                const currentDfSheet = exportWorkbook.addWorksheet(getSheetName(visibleTitle, DIRECTION.INPUT));
+                const currentDf = lastCall.inputs[dfInput.name];
+                dfToSheet(currentDfSheet, currentDf);
+            });
+            if (scalarInputs.length) {
+                const inputScalarsSheet = exportWorkbook.addWorksheet('Input scalars');
+                scalarsToSheet(inputScalarsSheet, scalarInputs.map((scalarInput) => ({
+                    caption: scalarInput.options['caption'] || scalarInput.name,
+                    value: lastCall.inputs[scalarInput.name],
+                    units: scalarInput.options['units'] || '',
+                })));
+            }
+            dfOutputs.forEach((dfOutput) => {
+                const visibleTitle = dfOutput.options.caption || dfOutput.name;
+                const currentDfSheet = exportWorkbook.addWorksheet(getSheetName(visibleTitle, DIRECTION.OUTPUT));
+                const currentDf = lastCall.outputs[dfOutput.name];
+                dfToSheet(currentDfSheet, currentDf);
+            });
+            if (scalarOutputs.length) {
+                const outputScalarsSheet = exportWorkbook.addWorksheet('Output scalars');
+                scalarsToSheet(outputScalarsSheet, scalarOutputs.map((scalarOutput) => ({
+                    caption: scalarOutput.options['caption'] || scalarOutput.name,
+                    value: lastCall.outputs[scalarOutput.name],
+                    units: scalarOutput.options['units'] || '',
+                })));
+            }
+            const buffer = yield exportWorkbook.xlsx.writeBuffer();
+            return new Blob([buffer], { type: BLOB_TYPE });
+        });
+    }
+}
+DefaultExportService.inject = [
+    tokens.stateService,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-service.js","sourceRoot":"","sources":["export-service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable valid-jsdoc */\n\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport ExcelJS from 'exceljs';\nimport {ExportService, StateService} from '../common/service-interfaces';\nimport {tokens} from '../common/inject-tokens';\n\nconst getSheetName = (name: string, direction: DIRECTION) => {\n  const idealName = `${direction} - ${name}`;\n  return (idealName.length > 31) ? name.substring(0, 32) : idealName;\n};\n\nenum DIRECTION {\n  INPUT = 'Input',\n  OUTPUT = 'Output'\n}\n\nconst scalarsToSheet = (sheet: ExcelJS.Worksheet, scalars: {caption: string, value: string, units: string}[]) => {\n  sheet.addRow(['Parameter', 'Value', 'Units']).font = {bold: true};\n  scalars.forEach((scalar) => {\n    sheet.addRow([scalar.caption, scalar.value, scalar.units]);\n  });\n\n  sheet.getColumn(1).width = Math.max(\n    ...scalars.map((scalar) => scalar.caption.toString().length), 'Parameter'.length,\n  ) * 1.2;\n  sheet.getColumn(2).width = Math.max(...scalars.map((scalar) => scalar.value.toString().length), 'Value'.length) * 1.2;\n  sheet.getColumn(3).width = Math.max(...scalars.map((scalar) => scalar.units.toString().length), 'Units'.length) * 1.2;\n};\n\nconst dfToSheet = (sheet: ExcelJS.Worksheet, df: DG.DataFrame) => {\n  sheet.addRow((df.columns as DG.ColumnList).names()).font = {bold: true};\n  for (let i = 0; i < df.rowCount; i++)\n    sheet.addRow([...df.row(i).cells].map((cell: DG.Cell) => cell.value));\n\n\n  for (let i = 0; i < df.columns.length; i++) {\n    sheet.getColumn(i+1).width =\n      Math.max(\n        ...(df.columns as DG.ColumnList).byIndex(i).categories.map((category) => category.toString().length),\n        (df.columns as DG.ColumnList).byIndex(i).name.length,\n      ) * 1.2;\n  }\n};\n\nexport class DefaultExportService implements ExportService {\n  public static inject = [\n    tokens.stateService,\n  ] as const;\n\n  constructor(\n    private state: StateService,\n  ) {}\n\n  filename(format: string): string {\n    return `${this.state.name} - ${new Date().toLocaleString()}.${this.supportedExportExtensions[format]}`;\n  }\n\n  /** Override to provide supported export formats.\n   * These formats are available under the \"Export\" popup on the ribbon panel. */\n  get supportedExportFormats(): string[] {\n    return [\n      'Excel',\n    ];\n  }\n\n  /** Override to provide custom file extensions for exported formats.\n   * These formats are available under the \"Export\" popup on the ribbon panel. */\n  get supportedExportExtensions(): Record<string, string> {\n    return {\n      'Excel': 'xlsx',\n    };\n  }\n\n  /** Override to provide custom export. */\n  async export(format: string): Promise<Blob> {\n    if (!this.state.func) throw new Error(`No function is associated with view`);\n\n    const lastCall = this.state.lastCall;\n    if (!lastCall) throw new Error(`Function was not called`);\n\n    if (format !== 'Excel') throw new Error(`Format \"${format}\" is not supported.`);\n\n    const BLOB_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';\n    const exportWorkbook = new ExcelJS.Workbook();\n\n    const isScalarType = (type: DG.TYPE) => (DG.TYPES_SCALAR.has(type));\n\n    const isDataFrame = (type: DG.TYPE) => (type === DG.TYPE.DATA_FRAME);\n\n    const dfInputs = this.state.func.inputs.filter((input) => isDataFrame(input.propertyType));\n    const scalarInputs = this.state.func.inputs.filter((input) => isScalarType(input.propertyType));\n    const dfOutputs = this.state.func.outputs.filter((output) => isDataFrame(output.propertyType));\n    const scalarOutputs = this.state.func.outputs.filter((output) => isScalarType(output.propertyType));\n\n    dfInputs.forEach((dfInput) => {\n      const visibleTitle = dfInput.options.caption || dfInput.name;\n      const currentDfSheet = exportWorkbook.addWorksheet(getSheetName(visibleTitle, DIRECTION.INPUT));\n\n      const currentDf = (lastCall.inputs[dfInput.name] as DG.DataFrame);\n      dfToSheet(currentDfSheet, currentDf);\n    });\n\n    if (scalarInputs.length) {\n      const inputScalarsSheet = exportWorkbook.addWorksheet('Input scalars');\n      scalarsToSheet(inputScalarsSheet, scalarInputs.map((scalarInput) => ({\n        caption: scalarInput.options['caption'] || scalarInput.name,\n        value: lastCall.inputs[scalarInput.name],\n        units: scalarInput.options['units'] || '',\n      })));\n    }\n\n    dfOutputs.forEach((dfOutput) => {\n      const visibleTitle = dfOutput.options.caption || dfOutput.name;\n      const currentDfSheet = exportWorkbook.addWorksheet(getSheetName(visibleTitle, DIRECTION.OUTPUT));\n\n      const currentDf = (lastCall.outputs[dfOutput.name] as DG.DataFrame);\n      dfToSheet(currentDfSheet, currentDf);\n    });\n\n    if (scalarOutputs.length) {\n      const outputScalarsSheet = exportWorkbook.addWorksheet('Output scalars');\n      scalarsToSheet(outputScalarsSheet, scalarOutputs.map((scalarOutput) => ({\n        caption: scalarOutput.options['caption'] || scalarOutput.name,\n        value: lastCall.outputs[scalarOutput.name],\n        units: scalarOutput.options['units'] || '',\n      })));\n    }\n\n    const buffer = await exportWorkbook.xlsx.writeBuffer();\n\n    return new Blob([buffer], {type: BLOB_TYPE});\n  }\n}\n"]}

package/src/computation-view/default-services/historical-run-service.d.ts

@@ -0,0 +1,8 @@
+import * as DG from 'datagrok-api/dg';
+import { HistoricalRunService } from '../common/service-interfaces';
+export declare class DefaultHistoricalRunService implements HistoricalRunService {
+    saveRun(call: DG.FuncCall): Promise<string>;
+    loadRun(runId: string): Promise<DG.FuncCall>;
+    pullRuns(): Promise<DG.FuncCall[]>;
+}
+//# sourceMappingURL=historical-run-service.d.ts.map