@ctzy-web-client/data-model 1.0.0 → 1.0.4

package/es/abstract/FilterPanel.mjs

@@ -0,0 +1,392 @@
+import { cloneDeep, isEqual, set, get, unset } from 'lodash';
+import { EventDispatcher, aesEncrypt } from '@ctzy-web-client/support';
+import FilterColumn from './FilterColumn.mjs';
+import { Where } from './where/Where.mjs';
+import { sortColumn } from '../utils/index.mjs';
+
+class FilterPanel extends EventDispatcher {
+  get isInited() {
+    return this._inited;
+  }
+  get ready() {
+    if (!this._inited) {
+      return false;
+    }
+    return this.existComponent ? this._ready : true;
+  }
+  set ready(value) {
+    if (!this._inited) {
+      return;
+    }
+    if (this.ready || this._ready === value) {
+      return;
+    }
+    this._ready = value;
+    this.emit("ready");
+  }
+  constructor(dataTable) {
+    super();
+    this._filterColumns = [];
+    this._selectedColumnAttrNames = [];
+    this._searchValue = "";
+    this._searchAttr = "";
+    this.fieldSearchValue = "";
+    this._filterParams = {};
+    this.existComponent = false;
+    this._inited = false;
+    this._ready = false;
+    this._isChange = false;
+    this._allowTriggerParamsChange = 0;
+    this._searchFields = [];
+    this.whereForFilter = false;
+    this.whereParamName = "";
+    this.encryptCondition = true;
+    this.dataTable = dataTable;
+    this.originFilterParams = {};
+    this.originSearchValue = "";
+  }
+  _formatFilterColumn(extendFieldInfo) {
+    const baseFilterColumnConfig = {
+      name: extendFieldInfo.name,
+      attrName: extendFieldInfo.name,
+      isExtend: true,
+      default: extendFieldInfo.defaultValue,
+      formComponent: extendFieldInfo.component,
+      closable: true,
+      title: extendFieldInfo.title,
+      fullAttrName: `${this.dataTable.extendField}.${extendFieldInfo.name}`
+    };
+    if (["BwaSelect"].includes(extendFieldInfo.component)) {
+      baseFilterColumnConfig.component = "BwaSingleMenuCondition";
+      baseFilterColumnConfig.componentProps = extendFieldInfo.extendInfo;
+    }
+    if (["BwaMultiSelect"].includes(extendFieldInfo.component)) {
+      baseFilterColumnConfig.component = "BwaMultipleMenuCondition";
+      baseFilterColumnConfig.componentProps = extendFieldInfo.extendInfo;
+    }
+    if (["BwaUserSelect"].includes(extendFieldInfo.component)) {
+      baseFilterColumnConfig.component = "BwaSingleUserCondition";
+    }
+    if (["BwaUserMultiSelect"].includes(extendFieldInfo.component)) {
+      baseFilterColumnConfig.component = "BwaMultiUserCondition";
+    }
+    return baseFilterColumnConfig;
+  }
+  _parseFilterColumns(extendFieldInfos, filterColumnConfigs) {
+    const allowComponents = ["BwaSelect", "BwaMultiSelect", "BwaUserSelect", "BwaUserMultiSelect"];
+    extendFieldInfos = extendFieldInfos.filter((extendFieldInfo) => extendFieldInfo.type != 1).filter((extendFieldInfo) => allowComponents.includes(extendFieldInfo.component));
+    const attrNames = Array.from(new Set(filterColumnConfigs.map((config) => config.attrName)));
+    extendFieldInfos = extendFieldInfos.filter((extendFieldInfo) => !attrNames.includes(extendFieldInfo.name));
+    const formatedExtendColumnConfigs = extendFieldInfos.map((item) => this._formatFilterColumn(item));
+    return [...filterColumnConfigs, ...formatedExtendColumnConfigs];
+  }
+  init(extendFieldInfos, filterColumnConfigs, filterColumnsOrder) {
+    if (this._inited) {
+      return;
+    }
+    this._inited = true;
+    filterColumnConfigs = this._parseFilterColumns(extendFieldInfos, filterColumnConfigs);
+    const filterColumns = sortColumn((filterColumnConfigs || []).map((filterColumnConfig) => new FilterColumn(this, filterColumnConfig)), filterColumnsOrder);
+    this.setColumns(filterColumns);
+    this._selectedColumnAttrNames = this.getAppliedColumns().map((column) => column.fullAttrName);
+    this._filterParams = {
+      ...this._getDefaultParams(),
+      ...this._filterParams
+    };
+    this.changeOriginFilterParams();
+    this._inited = true;
+    this.emit("initCompleted");
+  }
+  setSearchFields(searchFields) {
+    this._searchFields = searchFields.slice();
+  }
+  getSearchFields() {
+    return this._searchFields.slice();
+  }
+  changeOriginFilterParams(originFilterParams = this.getFilterParams()) {
+    this.originFilterParams = cloneDeep(originFilterParams);
+    this._checkChange();
+  }
+  changeOriginSearchValue(originSearchValue = this.getSearchValue()) {
+    this.originSearchValue = originSearchValue;
+    this._checkChange();
+  }
+  isChange() {
+    return this._isChange;
+  }
+  setIsChange(isChange) {
+    if (this._isChange === isChange) {
+      return;
+    }
+    this._isChange = isChange;
+  }
+  _checkChange() {
+    this.setIsChange(!isEqual(this.originFilterParams, this.getFilterParams()) || this.originSearchValue !== this.getSearchValue());
+  }
+  noTriggerParamsChange(callback) {
+    this._allowTriggerParamsChange++;
+    callback == null ? void 0 : callback();
+    this._allowTriggerParamsChange--;
+  }
+  getSearchValue() {
+    return this._searchValue;
+  }
+  _triggerParamsChange() {
+    if (this._allowTriggerParamsChange > 0) {
+      return;
+    }
+    this.emit("params-change");
+  }
+  setSeachValue(value, isSearch = false) {
+    this._searchValue = value;
+    this._checkChange();
+    if (!isSearch) {
+      this._triggerParamsChange();
+    }
+  }
+  setFilterParam(column, value, isSearch = false) {
+    if (this.getFilterParam(column) === value) {
+      return;
+    }
+    set(this._filterParams, column.fullAttrName, value);
+    this._checkChange();
+    if (!isSearch) {
+      this._triggerParamsChange();
+    }
+    this.emit("change-search-value");
+  }
+  getFilterParam(column) {
+    return get(this._filterParams, column.fullAttrName);
+  }
+  setSearchAttr(searchAttr) {
+    this._searchAttr = searchAttr;
+  }
+  getSearchAttr() {
+    return this._searchAttr;
+  }
+  _setFilterParams(filterParams, ignoreEmit = false) {
+    this._filterParams = cloneDeep(filterParams);
+    this._checkChange();
+    if (!ignoreEmit) {
+      this._triggerParamsChange();
+    }
+  }
+  getFilterParams() {
+    return this._filterParams;
+  }
+  appliedColumn(filterColumn) {
+    this._setFilterParams({
+      ...this._getDefaultParams(),
+      ...this.getFilterParams()
+    }, true);
+  }
+  cancelAppliedColumn(filterColumn) {
+    const filterParams = {
+      ...this._getDefaultParams(),
+      ...this.getFilterParams()
+    };
+    unset(filterParams, filterColumn.fullAttrName);
+    this._setFilterParams(filterParams, true);
+  }
+  _getDefaultParams() {
+    const filterParams = {};
+    for (const filterColumn of this.getVisibelColumns()) {
+      set(filterParams, filterColumn.fullAttrName, typeof filterColumn.default === "function" ? filterColumn.default() : filterColumn.default);
+    }
+    return filterParams;
+  }
+  resetFilterParams() {
+    this.noTriggerParamsChange(() => {
+      this._setFilterParams(this.originFilterParams);
+      this.setSeachValue("");
+    });
+    this._triggerParamsChange();
+  }
+  addColumn(filterColumn) {
+    if (this.getColumn(filterColumn.fullAttrName)) {
+      throw new Error("\u65E0\u6CD5\u6DFB\u52A0\u4E24\u4E2A\u5B57\u6BB5\u540D\u79F0\u4E00\u6837\u7684\u5B57\u6BB5:" + filterColumn.fullAttrName);
+    }
+    this._filterColumns.push(filterColumn);
+  }
+  removeColumn(filterColumn) {
+    this._filterColumns = this._filterColumns.filter((column) => column.attrName !== filterColumn.attrName);
+  }
+  getColumn(name) {
+    var _a;
+    return (_a = this.getColumns().find((column) => column.fullAttrName === name)) != null ? _a : null;
+  }
+  setColumns(fillterColumns) {
+    this._filterColumns = [];
+    for (let filterColumn of fillterColumns) {
+      this.addColumn(filterColumn);
+    }
+  }
+  getColumns() {
+    return this._filterColumns.slice();
+  }
+  getVisibelColumns() {
+    return this.getColumns().filter((column) => column.visible);
+  }
+  getFxiedColumns() {
+    return this.getVisibelColumns().filter((column) => !column.closable);
+  }
+  getClosableColumns() {
+    return this.getColumns().filter((column) => column.closable);
+  }
+  getSearchClosableColumns() {
+    const closableColumns = this.getClosableColumns();
+    return closableColumns.filter((column) => {
+      return column.title.includes(this.fieldSearchValue) || column.fullAttrName.toLocaleLowerCase().includes(this.fieldSearchValue);
+    });
+  }
+  getSelectedColumnAttrNames() {
+    return this._selectedColumnAttrNames.slice();
+  }
+  setSelectedColumnAttrNames(v) {
+    this._selectedColumnAttrNames = v;
+    for (let column of this.getClosableColumns()) {
+      column.visible = this._selectedColumnAttrNames.includes(column.fullAttrName);
+    }
+    this.emit("selected-column-change");
+  }
+  closeColumn(column) {
+    const selectedColumnAttrNames = this.getSelectedColumnAttrNames().filter((name) => name !== column.fullAttrName);
+    this.setSelectedColumnAttrNames(selectedColumnAttrNames);
+  }
+  getSelectedColumns() {
+    return this._selectedColumnAttrNames.map((attrName) => this.getColumn(attrName)).filter(Boolean).filter((column) => column.closable);
+  }
+  getAppliedColumns() {
+    return this.getFxiedColumns().concat(this.getSelectedColumns()).filter((column) => column.visible);
+  }
+  _parseWhereAttrMapping(where, column, params) {
+    var _a, _b;
+    const keys = Object.keys(column.attrMapping || {});
+    if (!keys.length) {
+      return;
+    }
+    let group = null;
+    if (column.twoFieldsDatePicker) {
+      const startInfo = (_a = column.attrMapping) == null ? void 0 : _a.start;
+      const endInfo = (_b = column.attrMapping) == null ? void 0 : _b.end;
+      if (!startInfo || !endInfo) {
+        return;
+      }
+      const startName = startInfo.name.replace("${name}", column.name).replace("${key}", "start");
+      const endName = endInfo.name.replace("${name}", column.name).replace("${key}", "end");
+      const object = get(params, this._formatFilterParamName(column.fullAttrName));
+      const start = get(object || {}, "start");
+      const end = get(object || {}, "end");
+      if (start && end) {
+        const group2 = where.addGroup();
+        const startGroup = group2.addOrGroup();
+        const endGroup = group2.addOrGroup();
+        startGroup.addCondition(startName, ">=", start);
+        startGroup.addCondition(startName, "<=", end);
+        endGroup.addCondition(endName, ">=", start);
+        endGroup.addCondition(endName, "<=", end);
+      }
+      return;
+    }
+    for (const key of keys) {
+      const info = column.attrMapping[key];
+      if (!info || typeof info !== "object") {
+        continue;
+      }
+      const name = info.name.replace("${name}", column.name).replace("${key}", key);
+      const object = get(params, this._formatFilterParamName(column.fullAttrName));
+      const value = get(object || {}, key);
+      if (value) {
+        group = group || where.addGroup();
+        switch (column.conditionOper) {
+          case "OR":
+            group.addOrCondition(name, info.op, value);
+            break;
+          case "AND":
+          default:
+            group.addCondition(name, info.op, value);
+        }
+      }
+    }
+  }
+  _getWhere(params) {
+    const where = new Where();
+    const columns = this.getAppliedColumns();
+    for (const column of columns) {
+      const key = this._formatFilterParamName(column.fullAttrName);
+      const value = get(params, key);
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          continue;
+        }
+        const isMultipleColumn = ["BwaMultiSelect", "BwaUserMultiSelect"].includes(column.formComponent);
+        where.addCondition(key, isMultipleColumn ? "json_contains" : "in", value);
+        continue;
+      }
+      if (typeof value === "object") {
+        if (!value) {
+          continue;
+        }
+        this._parseWhereAttrMapping(where, column, params);
+        continue;
+      }
+      if (value) {
+        where.addCondition(key, "=", value);
+      }
+    }
+    if (this.getSearchFields().length) {
+      if (this.getSearchValue()) {
+        const group = where.addGroup();
+        for (let field of this.getSearchFields()) {
+          group.addOrCondition(field, "like", `%${this.getSearchValue()}%`);
+        }
+      }
+    }
+    return this.encryptCondition ? aesEncrypt(JSON.stringify(where), "bwa-mkbl") : JSON.stringify(where);
+  }
+  _formatFilterParamName(paramName) {
+    const column = this.getColumn(paramName);
+    if (!column) {
+      return paramName;
+    }
+    let segments = column.fullAttrName.split(".");
+    segments.pop();
+    return [...segments, column.name].join(".");
+  }
+  _formatFilterParam(params, column, value) {
+    const key = this._formatFilterParamName(column.fullAttrName);
+    if (value && !Array.isArray(value) && typeof value === "object" && column.attrMapping && typeof column.attrMapping === "object" && Object.values(column.attrMapping).every((value2) => typeof value2 === "string")) {
+      for (const key2 of Reflect.ownKeys(column.attrMapping)) {
+        set(params, column.attrMapping[key2], value[key2]);
+      }
+      return;
+    }
+    set(params, key, value);
+  }
+  _getAjaxFilterParams() {
+    const filterParams = this.getFilterParams();
+    const columns = this.getColumns();
+    const params = {};
+    for (const column of columns) {
+      this._formatFilterParam(params, column, get(filterParams, column.fullAttrName));
+    }
+    return params;
+  }
+  getAjaxParams() {
+    let ajaxFilterParams = this._getAjaxFilterParams();
+    if (this.whereForFilter) {
+      return {
+        [this.whereParamName]: this._getWhere(ajaxFilterParams)
+      };
+    }
+    if (this.getSearchAttr()) {
+      ajaxFilterParams = {
+        [this.getSearchAttr()]: this.getSearchValue(),
+        ...ajaxFilterParams
+      };
+    }
+    return ajaxFilterParams;
+  }
+}
+
+export { FilterPanel };

package/es/abstract/FormColumn.mjs

@@ -0,0 +1,27 @@
+import DataColumn from './DataColumn.mjs';
+
+class FormColumn extends DataColumn {
+  constructor(options = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    super(options);
+    this.submitName = "";
+    this.rules = [];
+    this.required = true;
+    this.disabled = false;
+    this.submitName = (_a = options == null ? void 0 : options.submitName) != null ? _a : this.submitName;
+    this.rules = (_b = options == null ? void 0 : options.rules) != null ? _b : this.rules;
+    this.required = (_c = options == null ? void 0 : options.required) != null ? _c : this.required;
+    this.disabled = (_f = (_e = options == null ? void 0 : options.disabled) != null ? _e : (_d = this.componentProps) == null ? void 0 : _d.disabled) != null ? _f : false;
+    if (this.componentProps && typeof this.componentProps === "object") {
+      Reflect.deleteProperty(this.componentProps, "disabled");
+    }
+  }
+  disable() {
+    this.disabled = true;
+  }
+  enable() {
+    this.disabled = false;
+  }
+}
+
+export { FormColumn as default };

package/es/abstract/TableColumn.mjs

@@ -0,0 +1,34 @@
+import DataColumn from './DataColumn.mjs';
+
+const DEFAULT_SETTINGS = {
+  visible: true,
+  disabled: false
+};
+class TableColumn extends DataColumn {
+  constructor(options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    super(options);
+    this.width = "auto";
+    this.formComponent = "";
+    this.align = "center";
+    this.rule = "";
+    this.template = "${value}";
+    this.type = "string";
+    this.settings = null;
+    this.sortable = "";
+    this.width = (_a = options == null ? void 0 : options.width) != null ? _a : this.width;
+    this.formComponent = (_b = options.formComponent) != null ? _b : this.formComponent;
+    this.align = (_c = options == null ? void 0 : options.align) != null ? _c : this.align;
+    this.rule = (_d = options == null ? void 0 : options.rule) != null ? _d : this.rule;
+    this.template = (_e = options == null ? void 0 : options.template) != null ? _e : this.template;
+    this.type = (_f = options == null ? void 0 : options.type) != null ? _f : this.type;
+    this.default = (_g = options == null ? void 0 : options.default) != null ? _g : "-";
+    this.settings = {
+      ...DEFAULT_SETTINGS,
+      ...options == null ? void 0 : options.settings
+    };
+    this.sortable = (_h = options == null ? void 0 : options.sortable) != null ? _h : this.sortable;
+  }
+}
+
+export { TableColumn as default };

package/es/abstract/dataForm2.mjs

@@ -0,0 +1,178 @@
+import get from 'lodash/get';
+import { DATA_FORM, DATA_FORM_COLUMNS } from '../decorator/constant.mjs';
+import { sortColumn } from '../utils/index.mjs';
+import DataModel from './DataModel.mjs';
+import FormColumn from './FormColumn.mjs';
+
+class DataForm extends DataModel {
+  constructor(option) {
+    super(option);
+    this.changed = false;
+    this.locking = false;
+    this.disabled = false;
+    this.data = {};
+    this.formValivators = [];
+    this._loadCallbacks = [];
+    this._inited = false;
+  }
+  setOptions(options) {
+    if (!options.model) {
+      return;
+    }
+    super.setOptions({
+      ...options.model[DATA_FORM],
+      model: options.model
+    });
+  }
+  disable() {
+    this.disabled = true;
+  }
+  enable() {
+    this.disabled = false;
+  }
+  init() {
+    super.init();
+    const model = this.model;
+    if (!model) {
+      return;
+    }
+    if (this.extendField) {
+      return;
+    } else {
+      const columns = (model[DATA_FORM_COLUMNS] || []).map((columnConfig) => new FormColumn(columnConfig));
+      for (const column of columns) {
+        this.addColumn(column);
+      }
+      model.formColumns = this.getColumns().map((column) => column.attrName);
+    }
+    this.setData(null);
+    this._inited = true;
+    this.emit("init-completed");
+  }
+  setExtendFieldInfos(extendFieldInfos) {
+    if (this._inited) {
+      return;
+    }
+    this.extendFieldInfos = extendFieldInfos;
+    const formColumns = extendFieldInfos.map((extendField) => {
+      var _a;
+      return new FormColumn({
+        name: extendField.name,
+        title: extendField.title,
+        attrName: extendField.name,
+        submitName: extendField.name,
+        default: extendField.defaultValue || "",
+        isExtend: !extendField.type,
+        required: !!extendField.isRequired,
+        component: extendField.component,
+        componentProps: (_a = extendField.extendInfo) != null ? _a : {},
+        fullAttrName: `${this.extendField}.${extendField.name}`
+      });
+    });
+    this.setColumns(formColumns);
+    this.setData(null);
+    this._inited = true;
+    for (const callback of this._loadCallbacks) {
+      callback();
+    }
+    this.emit("init-completed");
+  }
+  setData(data) {
+    if (data) {
+      this.data = data;
+    } else {
+      this.reset();
+    }
+    this.ready = true;
+  }
+  reset() {
+    this.setData(this.formatData({}));
+  }
+  async loadDataByRecId(params) {
+    if (!this._inited) {
+      return new Promise((resolve, reject) => {
+        this._loadCallbacks.push(() => {
+          this.loadDataByRecId(params).then(resolve, reject);
+        });
+      });
+    }
+    this.locking = true;
+    if (typeof params !== "object") {
+      params = {
+        [this.primaryKey]: params
+      };
+    }
+    params = {
+      ...this.defaultParams,
+      ...params
+    };
+    this.emit("before-load", params);
+    return this.adapter.loadDataByRecIdHandle(this, params).then((res) => {
+      const data = this.formatData(Array.isArray(res.data) ? res.data[0] : res.data);
+      this.setData(data);
+      this.emit("load-successfully", res);
+      return res;
+    }).catch((e) => {
+      this.emit("load-failed", e);
+      return Promise.reject(e);
+    }).finally(() => {
+      this.locking = false;
+      this.emit("load-complete");
+    });
+  }
+  formatSubmitData(data) {
+    return this._format(data, "submitName");
+  }
+  sortColumns(columns) {
+    return sortColumn(columns, this.model.formColumns || []);
+  }
+  async validate() {
+    if (!this.formValivators.length) {
+      return Promise.resolve(false);
+    }
+    const validateResults = await Promise.all(this.formValivators.map((validator) => validator.validate().then(() => true, () => false)));
+    return validateResults.reduce((result, item) => result && item, true);
+  }
+  async submit(data = {}) {
+    if (this.disabled) {
+      throw new Error("\u7981\u7528\u72B6\u6001\u4E0D\u80FD\u4FDD\u5B58");
+    }
+    if (this.locking) {
+      return;
+    }
+    if (!await this.validate()) {
+      return;
+    }
+    this.locking = true;
+    const submitData = {};
+    for (let column of this.getColumns().filter((column2) => !column2.isExtend)) {
+      submitData[column.submitName] = this.data[column.attrName];
+    }
+    if (this.extendField) {
+      let extendObject = {};
+      for (let column of this.getColumns().filter((column2) => column2.isExtend)) {
+        extendObject[column.attrName] = get(this.data, column.fullAttrName);
+      }
+      submitData[this.extendField] = extendObject;
+    }
+    Object.assign(submitData, data);
+    this.emit("before-submit", data);
+    return this.adapter.submitHandle(this, submitData).then((res) => {
+      this.emit("submit-successfully", res);
+      return res;
+    }).catch((e) => {
+      this.emit("submit-failed", e);
+      return Promise.reject(e);
+    }).finally(() => {
+      this.emit("submit-complete");
+      this.locking = false;
+    });
+  }
+  setDisplayColumns(displayColumns) {
+    const displayColumnNames = displayColumns.map((column) => column.fullAttrName);
+    this._displayColumns = this.getColumns().filter((column) => displayColumnNames.includes(column.fullAttrName));
+    this.getDisplayColumnsSubject().next(this.getDisplayColumns());
+  }
+}
+
+export { DataForm as default };

package/es/abstract/where/CombineCondition.mjs

@@ -0,0 +1,63 @@
+import { Condition } from './Condition.mjs';
+import { SingleCondition } from './SingleCondition.mjs';
+
+class CombineCondition extends Condition {
+  constructor(...args) {
+    super(...args);
+    this.conditions = [];
+  }
+  addCondition(fieldName, operator, value) {
+    const condition = new SingleCondition(fieldName, operator, value);
+    if (this.conditions.length) {
+      this.conditions.push("AND");
+    }
+    this.conditions.push(condition);
+    return condition;
+  }
+  addOrCondition(fieldName, operator, value) {
+    const condition = new SingleCondition(fieldName, operator, value);
+    if (this.conditions.length) {
+      this.conditions.push("OR");
+    }
+    this.conditions.push(condition);
+    return condition;
+  }
+  addGroup(group) {
+    const _group = group || new CombineCondition();
+    if (this.conditions.length) {
+      this.conditions.push("AND");
+    }
+    this.conditions.push(_group);
+    return _group;
+  }
+  addOrGroup(group) {
+    const _group = group || new CombineCondition();
+    if (this.conditions.length) {
+      this.conditions.push("OR");
+    }
+    this.conditions.push(_group);
+    return _group;
+  }
+  removeCondition(fieldName) {
+    let index = this.conditions.findIndex((condition) => condition instanceof SingleCondition && condition.f === fieldName);
+    if (index === 0) {
+      this.conditions.splice(index, 1);
+      return;
+    }
+    this.conditions.splice(index - 1, 2);
+    const combineConditions = this.conditions.filter((condition) => condition instanceof CombineCondition);
+    for (let i = combineConditions.length - 1; i >= 0; i--) {
+      const combineCondition = combineConditions[i];
+      combineCondition.removeCondition(fieldName);
+      if (!combineCondition.conditions.length) {
+        const index2 = this.conditions.indexOf(combineCondition);
+        this.conditions.splice(index2, 1);
+      }
+    }
+  }
+  toJSON() {
+    return this.conditions.map((condition) => condition instanceof Condition ? condition.toJSON() : condition);
+  }
+}
+
+export { CombineCondition };

package/es/abstract/where/Condition.mjs

@@ -0,0 +1,4 @@
+class Condition {
+}
+
+export { Condition };