@mat3ra/wode 2025.10.1-0

package/dist/units/builders/UnitConfigBuilder.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnitConfigBuilder = void 0;
+var _utils = require("@mat3ra/utils");
+var _underscore = _interopRequireDefault(require("underscore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class UnitConfigBuilder {
+  constructor({
+    name,
+    type,
+    flowchartId
+  }) {
+    this.type = type;
+    this._name = name;
+    this._head = false;
+    this._results = [];
+    this._monitors = [];
+    this._preProcessors = [];
+    this._postProcessors = [];
+    this._flowchartId = flowchartId || this.constructor.generateFlowChartId(name);
+  }
+  name(str) {
+    this._name = str;
+    return this;
+  }
+  head(bool) {
+    this._head = bool;
+    return this;
+  }
+  static generateFlowChartId(...args) {
+    if (this.usePredefinedIds) return _utils.Utils.uuid.getUUIDFromNamespace(...args);
+    return _utils.Utils.uuid.getUUID();
+  }
+  flowchartId(flowchartId) {
+    this._flowchartId = flowchartId;
+    return this;
+  }
+  static _stringArrayToNamedObject(array) {
+    return array.map(name => _underscore.default.isString(name) ? {
+      name
+    } : name);
+  }
+  addPreProcessors(preProcessorNames) {
+    this._preProcessors = _underscore.default.union(this.constructor._stringArrayToNamedObject(preProcessorNames), this._preProcessors);
+    return this;
+  }
+  addPostProcessors(postProcessorNames) {
+    this._postProcessors = _underscore.default.union(this.constructor._stringArrayToNamedObject(postProcessorNames), this._postProcessors);
+    return this;
+  }
+  addResults(resultNames) {
+    this._results = _underscore.default.union(this.constructor._stringArrayToNamedObject(resultNames), this._results);
+    return this;
+  }
+  addMonitors(monitorNames) {
+    this._monitors = _underscore.default.union(this.constructor._stringArrayToNamedObject(monitorNames), this._monitors);
+    return this;
+  }
+  build() {
+    return {
+      type: this.type,
+      name: this._name,
+      head: this._head,
+      results: this._results,
+      monitors: this._monitors,
+      flowchartId: this._flowchartId,
+      preProcessors: this._preProcessors,
+      postProcessors: this._postProcessors
+    };
+  }
+}
+exports.UnitConfigBuilder = UnitConfigBuilder;
+_defineProperty(UnitConfigBuilder, "usePredefinedIds", false);

package/dist/units/builders/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.builders = void 0;
+var _AssertionUnitConfigBuilder = require("./AssertionUnitConfigBuilder");
+var _AssignmentUnitConfigBuilder = require("./AssignmentUnitConfigBuilder");
+var _ExecutionUnitConfigBuilder = require("./ExecutionUnitConfigBuilder");
+var _IOUnitConfigBuilder = require("./IOUnitConfigBuilder");
+var _UnitConfigBuilder = require("./UnitConfigBuilder");
+const builders = exports.builders = {
+  UnitConfigBuilder: _UnitConfigBuilder.UnitConfigBuilder,
+  AssignmentUnitConfigBuilder: _AssignmentUnitConfigBuilder.AssignmentUnitConfigBuilder,
+  AssertionUnitConfigBuilder: _AssertionUnitConfigBuilder.AssertionUnitConfigBuilder,
+  ExecutionUnitConfigBuilder: _ExecutionUnitConfigBuilder.ExecutionUnitConfigBuilder,
+  IOUnitConfigBuilder: _IOUnitConfigBuilder.IOUnitConfigBuilder
+};

package/dist/units/condition.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConditionUnit = void 0;
+var _enums = require("../enums");
+var _base = require("./base");
+class ConditionUnit extends _base.BaseUnit {
+  constructor(config) {
+    super({
+      ...ConditionUnit.getConditionConfig(),
+      ...config
+    });
+  }
+  static getConditionConfig() {
+    return {
+      name: _enums.UNIT_TYPES.condition,
+      type: _enums.UNIT_TYPES.condition,
+      input: [],
+      results: [],
+      preProcessors: [],
+      postProcessors: [],
+      then: undefined,
+      else: undefined,
+      statement: "true",
+      maxOccurrences: 100
+    };
+  }
+  get input() {
+    return this.prop("input");
+  }
+  get then() {
+    return this.prop("then");
+  }
+  get else() {
+    return this.prop("else");
+  }
+  get statement() {
+    return this.prop("statement");
+  }
+  get maxOccurrences() {
+    return this.prop("maxOccurrences");
+  }
+  getHashObject() {
+    return {
+      statement: this.statement,
+      maxOccurrences: this.maxOccurrences
+    };
+  }
+}
+exports.ConditionUnit = ConditionUnit;

package/dist/units/execution.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExecutionUnit = void 0;
+var _ade = require("@exabyte-io/ade.js");
+var _ApplicationRegistry = _interopRequireDefault(require("@exabyte-io/ade.js/dist/js/ApplicationRegistry"));
+var _utils = require("@mat3ra/utils");
+var _underscore = _interopRequireDefault(require("underscore"));
+var _base = require("./base");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class ExecutionUnit extends _base.BaseUnit {
+  /**
+   * @override this method to provide entities from other sources
+   */
+  _initApplication(config) {
+    this._application = _ApplicationRegistry.default.createApplication(config.application);
+    this._executable = _ApplicationRegistry.default.getExecutableByConfig(this._application.name, config.executable);
+    this._flavor = _ApplicationRegistry.default.getFlavorByConfig(this._executable, config.flavor);
+    this._templates = this._flavor ? this._flavor.inputAsTemplates : [];
+  }
+
+  /**
+   * @override this method to provide default executable from other source
+   */
+  _getDefaultExecutable() {
+    return _ApplicationRegistry.default.getExecutableByName(this.application.name);
+  }
+
+  /**
+   * @override this method to provide default flavor from other source
+   */
+  _getDefaultFlavor() {
+    return _ApplicationRegistry.default.getFlavorByName(this.executable.name);
+  }
+
+  /**
+   * @override this method to provide custom templates
+   */
+  _getTemplatesFromInput() {
+    return this.getInput().map(i => new _ade.Template(i));
+  }
+
+  /**
+   * @override this method to provide custom input from other sources
+   */
+  _getInput() {
+    return this.input || _ApplicationRegistry.default.getInputAsRenderedTemplates(this.flavor, this.getCombinedContext()) || [];
+  }
+
+  /**
+   * @override this method to provide custom input as templates
+   */
+  _getInputAsTemplates() {
+    return _ApplicationRegistry.default.getInputAsTemplates(this.flavor);
+  }
+  _initRuntimeItems(keys, config) {
+    this._initApplication(config);
+    super._initRuntimeItems(keys);
+  }
+
+  /*
+   * @summary expects an array with elements containing field [{content: "..."}]
+   */
+  get hashFromArrayInputContent() {
+    const objectForHashing = this._getInput().map(i => {
+      return _utils.Utils.str.removeEmptyLinesFromString(_utils.Utils.str.removeCommentsFromSourceCode(i.content));
+    });
+    return _utils.Utils.hash.calculateHashFromObject(objectForHashing);
+  }
+  get name() {
+    return this.prop("name", this.flavor.name);
+  }
+  get application() {
+    return this._application;
+  }
+  get executable() {
+    return this._executable;
+  }
+  get flavor() {
+    return this._flavor;
+  }
+  get templates() {
+    return this._templates;
+  }
+  setApplication(application, omitSettingExecutable = false) {
+    this._application = application;
+    this.setProp("application", application.toJSON());
+    if (!omitSettingExecutable) {
+      this.setExecutable(this._getDefaultExecutable());
+    }
+  }
+  setExecutable(executable) {
+    this._executable = executable;
+    this.setProp("executable", executable.toJSON());
+    this.setFlavor(this._getDefaultFlavor());
+  }
+  setFlavor(flavor) {
+    this._flavor = flavor;
+    this.setRuntimeItemsToDefaultValues();
+    this.setProp("flavor", flavor.toJSON());
+    this.setTemplates(this._getInputAsTemplates());
+  }
+  setTemplates(templates) {
+    this._templates = templates;
+    this.render(this.context, true);
+  }
+  setInput(input) {
+    this.setProp("input", input);
+  }
+  get defaultResults() {
+    return this.flavor.results;
+  }
+  get defaultMonitors() {
+    return this.flavor.monitors;
+  }
+  get defaultPostProcessors() {
+    return this.flavor.postProcessors;
+  }
+  get allowedResults() {
+    return this.executable.results;
+  }
+  get allowedMonitors() {
+    return this.executable.monitors;
+  }
+  get allowedPostProcessors() {
+    return this.executable.postProcessors;
+  }
+  get allContextProviders() {
+    const list = [];
+    // pass context below to keep UI changes
+    this.templates.forEach(i => list.push(...i.getContextProvidersAsClassInstances(this.getCombinedContext())));
+    return list;
+  }
+  get contextProviders() {
+    return this.allContextProviders.filter(p => p.isUnitContextProvider);
+  }
+  get input() {
+    return this.prop("input");
+  }
+  get renderingContext() {
+    return this._renderingContext || {};
+  }
+  set renderingContext(ctx) {
+    this._renderingContext = ctx;
+  }
+
+  // context to persist in toJSON
+  get storedContext() {
+    return _underscore.default.omit(this.context, ...this.constructor.omitKeys);
+  }
+
+  // context to show to users with some extra keys omitted
+  get visibleRenderingContext() {
+    return _underscore.default.omit(this.renderingContext, ...this.constructor.omitKeys);
+  }
+  static getSubworkflowContext(context) {
+    const {
+      subworkflowContext
+    } = context;
+    return subworkflowContext ? {
+      subworkflowContext
+    } : {};
+  }
+
+  /** Update rendering context and persistent context
+   * Note: this function is sometimes being called without passing a context!
+   * @param context
+   * @param fromTemplates
+   */
+  render(context, fromTemplates = false) {
+    const newInput = [];
+    const newPersistentContext = {};
+    const newRenderingContext = {};
+    const renderingContext = {
+      ...this.context,
+      ...context
+    };
+    this.updateContext(renderingContext); // update in-memory context to properly render templates from input below
+    (fromTemplates ? this.templates : this._getTemplatesFromInput()).forEach(t => {
+      newInput.push(t.getRenderedJSON(renderingContext));
+      Object.assign(newRenderingContext, t.getDataFromProvidersForRenderingContext(renderingContext), ExecutionUnit.getSubworkflowContext(renderingContext));
+      Object.assign(newPersistentContext, t.getDataFromProvidersForPersistentContext(renderingContext), ExecutionUnit.getSubworkflowContext(renderingContext));
+    });
+    this.setInput(newInput);
+    this.renderingContext = newRenderingContext;
+    this.updatePersistentContext(newPersistentContext);
+  }
+
+  /**
+   * @summary Calculates hash on unit-specific fields.
+   * The meaningful fields of processing unit are operation, flavor and input at the moment.
+   */
+  getHashObject() {
+    return {
+      ...super.getHashObject(),
+      application: _utils.Utils.specific.removeTimestampableKeysFromConfig(this.application.toJSON()),
+      executable: _utils.Utils.specific.removeTimestampableKeysFromConfig(this.executable.toJSON()),
+      flavor: _utils.Utils.specific.removeTimestampableKeysFromConfig(this.flavor.toJSON()),
+      input: this.hashFromArrayInputContent
+    };
+  }
+  toJSON() {
+    return this.clean({
+      ...super.toJSON(),
+      executable: this.executable.toJSON(),
+      flavor: this.flavor.toJSON(),
+      input: this._getInput(),
+      // keys below are not propagated to the parent class on initialization of a new unit unless explicitly given
+      name: this.name
+      // TODO: figure out the problem with storing context below
+      // context: this.storedContext,
+    });
+  }
+}
+exports.ExecutionUnit = ExecutionUnit;
+// keys to be omitted during toJSON
+_defineProperty(ExecutionUnit, "omitKeys", ["job", "workflow", "material", "materials", "model", "methodData", "hasRelaxation"]);

package/dist/units/factory.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnitFactory = void 0;
+var _enums = require("../enums");
+var _assertion = require("./assertion");
+var _assignment = require("./assignment");
+var _base = require("./base");
+var _condition = require("./condition");
+var _execution = require("./execution");
+var _io = require("./io");
+var _map = require("./map");
+var _processing = require("./processing");
+var _subworkflow = require("./subworkflow");
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class UnitFactory {
+  static create(config) {
+    switch (config.type) {
+      case _enums.UNIT_TYPES.execution:
+        return new this.ExecutionUnit(config);
+      case _enums.UNIT_TYPES.assignment:
+        return new this.AssignmentUnit(config);
+      case _enums.UNIT_TYPES.condition:
+        return new this.ConditionUnit(config);
+      case _enums.UNIT_TYPES.io:
+        return new this.IOUnit(config);
+      case _enums.UNIT_TYPES.processing:
+        return new this.ProcessingUnit(config);
+      case _enums.UNIT_TYPES.map:
+        return new this.MapUnit(config);
+      case _enums.UNIT_TYPES.subworkflow:
+        return new this.SubworkflowUnit(config);
+      case _enums.UNIT_TYPES.assertion:
+        return new this.AssertionUnit(config);
+      default:
+        return new this.BaseUnit(config);
+    }
+  }
+}
+exports.UnitFactory = UnitFactory;
+_defineProperty(UnitFactory, "AssertionUnit", _assertion.AssertionUnit);
+_defineProperty(UnitFactory, "AssignmentUnit", _assignment.AssignmentUnit);
+_defineProperty(UnitFactory, "BaseUnit", _base.BaseUnit);
+_defineProperty(UnitFactory, "ConditionUnit", _condition.ConditionUnit);
+_defineProperty(UnitFactory, "ExecutionUnit", _execution.ExecutionUnit);
+_defineProperty(UnitFactory, "IOUnit", _io.IOUnit);
+_defineProperty(UnitFactory, "MapUnit", _map.MapUnit);
+_defineProperty(UnitFactory, "ProcessingUnit", _processing.ProcessingUnit);
+_defineProperty(UnitFactory, "SubworkflowUnit", _subworkflow.SubworkflowUnit);

package/dist/units/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AssertionUnit", {
+  enumerable: true,
+  get: function () {
+    return _assertion.AssertionUnit;
+  }
+});
+Object.defineProperty(exports, "AssignmentUnit", {
+  enumerable: true,
+  get: function () {
+    return _assignment.AssignmentUnit;
+  }
+});
+Object.defineProperty(exports, "BaseUnit", {
+  enumerable: true,
+  get: function () {
+    return _base.BaseUnit;
+  }
+});
+Object.defineProperty(exports, "ConditionUnit", {
+  enumerable: true,
+  get: function () {
+    return _condition.ConditionUnit;
+  }
+});
+Object.defineProperty(exports, "ExecutionUnit", {
+  enumerable: true,
+  get: function () {
+    return _execution.ExecutionUnit;
+  }
+});
+Object.defineProperty(exports, "IOUnit", {
+  enumerable: true,
+  get: function () {
+    return _io.IOUnit;
+  }
+});
+Object.defineProperty(exports, "MapUnit", {
+  enumerable: true,
+  get: function () {
+    return _map.MapUnit;
+  }
+});
+Object.defineProperty(exports, "ProcessingUnit", {
+  enumerable: true,
+  get: function () {
+    return _processing.ProcessingUnit;
+  }
+});
+Object.defineProperty(exports, "ReduceUnit", {
+  enumerable: true,
+  get: function () {
+    return _reduce.ReduceUnit;
+  }
+});
+Object.defineProperty(exports, "SubworkflowUnit", {
+  enumerable: true,
+  get: function () {
+    return _subworkflow.SubworkflowUnit;
+  }
+});
+Object.defineProperty(exports, "UnitFactory", {
+  enumerable: true,
+  get: function () {
+    return _factory.UnitFactory;
+  }
+});
+var _assertion = require("./assertion");
+var _assignment = require("./assignment");
+var _base = require("./base");
+var _condition = require("./condition");
+var _execution = require("./execution");
+var _factory = require("./factory");
+var _io = require("./io");
+var _map = require("./map");
+var _processing = require("./processing");
+var _reduce = require("./reduce");
+var _subworkflow = require("./subworkflow");

package/dist/units/io.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IOUnit = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _enums = require("../enums");
+var _base = require("./base");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class IOUnit extends _base.BaseUnit {
+  /**
+   * IO Unit Builder for Object Storage sources.
+   *
+   * @param {Object} config - config object with other parameters:
+   * @param {String} config.name - the name of the unit this builder is creating
+   * @param {String} config.subtype - "input", "output", or "dataframe"
+   * @param {Object} config.input - input containing information on the file to download
+   * @param {Boolean} config.enableRender - Whether to use Jinja templating at runtime
+   */
+  constructor(config) {
+    super({
+      ...IOUnit.getIOConfig(),
+      ...config
+    });
+    this.initialize(config);
+  }
+  static getIOConfig() {
+    return {
+      name: _enums.UNIT_TYPES.io,
+      type: _enums.UNIT_TYPES.io,
+      subtype: "input"
+    };
+  }
+  initialize(config) {
+    this._materials = [];
+    this._defaultTargets = ["band_gaps:direct", "band_gaps:indirect"];
+    this._features = _lodash.default.get(config, "input.0.endpoint_options.data.features", []);
+    this._targets = _lodash.default.get(config, "input.0.endpoint_options.data.targets", this._defaultTargets);
+    this._ids = _lodash.default.get(config, "input.0.endpoint_options.data.ids", []);
+    this._jobId = null;
+  }
+  get materials() {
+    return this._materials || [];
+  }
+  get defaultTargets() {
+    return this._defaultTargets;
+  }
+  get features() {
+    return this._features;
+  }
+  get featuresWithoutId() {
+    return this.features.filter(x => x !== _enums.IO_ID_COLUMN);
+  }
+  get availableFeatures() {
+    const {
+      materials
+    } = this;
+    return _lodash.default.uniq(_lodash.default.flatten(materials.map(x => _lodash.default.keys(x.propertiesDict()))).concat(this.features));
+  }
+  get availableFeaturesWithoutId() {
+    return this.availableFeatures.filter(feature => feature !== _enums.IO_ID_COLUMN);
+  }
+  get targets() {
+    return this._targets;
+  }
+
+  /**
+   * @summary Checks whether selected features contain only IO_ID_COLUMN ('exabyteId').
+   * Used to identify that no features are selected yet (features set always contains ID_COLUMN)
+   */
+  get onlyIdFeatureSelected() {
+    return _lodash.default.isEmpty(_lodash.default.without(this.features, _enums.IO_ID_COLUMN));
+  }
+
+  /**
+   * @summary Returns object with targets as key and arrays of appropriate values.
+   * E.g. {'band_gap:indirect': [0.1, 0.3], 'pressure': [100, undefined]}
+   */
+  get valuesByTarget() {
+    const values = this.dataGridValues;
+    const result = {};
+    this.targets.forEach(target => {
+      result[target] = values.map(v => v[target]);
+    });
+    return result;
+  }
+  get dataFrameConfig() {
+    return {
+      subtype: "dataFrame",
+      source: "api",
+      input: [{
+        endpoint: "dataframe",
+        endpoint_options: {
+          method: "POST",
+          data: {
+            targets: this._targets,
+            features: this._features,
+            ids: this._ids,
+            jobId: this._jobId
+          },
+          headers: {},
+          params: {}
+        }
+      }]
+    };
+  }
+  get isDataFrame() {
+    return this.prop("subtype") === "dataFrame";
+  }
+  setMaterials(materials) {
+    this._materials = materials;
+    this._ids = materials.map(m => m.exabyteId);
+  }
+  addFeature(feature) {
+    // only add if not already present
+    if (this._features.indexOf(feature) === -1) this._features.push(feature);
+  }
+  removeFeature(feature) {
+    if (this.featuresWithoutId.length === 1) {
+      throw new Error("At least one feature is required");
+    }
+    this._features = this._features.filter(x => feature !== x && x !== _enums.IO_ID_COLUMN);
+  }
+  addTarget(target) {
+    if (this._targets.indexOf(target) === -1) this._targets.push(target);
+  }
+  removeTarget(target) {
+    if (this._targets.length === 1) {
+      throw new Error("At least one target is required");
+    }
+    this._targets = this._targets.filter(x => target !== x);
+  }
+  hasFeature(feature) {
+    return this._features.indexOf(feature) > -1;
+  }
+  hasTarget(target) {
+    return this._targets.indexOf(target) > -1;
+  }
+  toJSON() {
+    const config = this.isDataFrame ? this.dataFrameConfig : {};
+    return this.clean({
+      ...super.toJSON(),
+      ...config
+    });
+  }
+}
+exports.IOUnit = IOUnit;

package/dist/units/map.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultMapConfig = exports.MapUnit = void 0;
+var _enums = require("../enums");
+var _base = require("./base");
+const defaultMapConfig = exports.defaultMapConfig = {
+  name: _enums.UNIT_TYPES.map,
+  type: _enums.UNIT_TYPES.map,
+  workflowId: "",
+  input: {
+    target: "MAP_DATA",
+    scope: "global",
+    name: "",
+    values: [],
+    useValues: false
+  }
+};
+class MapUnit extends _base.BaseUnit {
+  constructor(config) {
+    super({
+      ...defaultMapConfig,
+      ...config
+    });
+  }
+  get input() {
+    return this.prop("input");
+  }
+  get workflowId() {
+    return this.prop("workflowId");
+  }
+  setWorkflowId(id) {
+    this.setProp("workflowId", id);
+  }
+}
+exports.MapUnit = MapUnit;