cnhis-design-vue 3.1.40-beta.1 → 3.1.40-beta.11

package/es/components/table-filter/src/tool/generateDefOptions.d.ts

@@ -0,0 +1,14 @@
+export declare const generateDefOptionsInSql: (widgetType: string, mappingConfig?: {
+    mappingMethod: null;
+    mapping: never[];
+}, optionSetting?: null) => {
+    label: string;
+    value: string;
+}[];
+export declare const generateDefOptionsInApi: (widgetType: string, mappingConfig?: {
+    mappingMethod: null;
+    mapping: never[];
+}) => {
+    label: string;
+    value: string;
+}[];

package/es/components/table-filter/src/tool/generateDefOptions.js

@@ -0,0 +1,65 @@
+import { WidgetTypeEnums, MappingMethodEnums, WidgetValEnums, DataTypeEnums, WidgetOptionEnums } from '../types/enums.js';
+import { widgetValOptions } from './options.js';
+import { isNil } from './utils.js';
+
+const generateDefOptionsInSql = (widgetType, mappingConfig = {
+  mappingMethod: null,
+  mapping: []
+}, optionSetting = null) => {
+  var _a, _b;
+  if (isNil(widgetType))
+    return [];
+  if (widgetType === WidgetTypeEnums.SELECT) {
+    const { mapping, mappingMethod } = mappingConfig;
+    if (mapping && mappingMethod) {
+      return mappingMethod === MappingMethodEnums.DICT ? [{ label: "\u9ED8\u8BA4\u9009\u4E2D\u7B2C\u4E00\u9879", value: WidgetValEnums.FIRST_VAL }] : mapping;
+    }
+  }
+  let options = (_b = (_a = widgetValOptions[DataTypeEnums.SQL]) == null ? void 0 : _a[widgetType]) != null ? _b : [];
+  if (optionSetting === WidgetOptionEnums.FUTURE_TIME) {
+    const enums = [
+      WidgetValEnums.TODAY,
+      WidgetValEnums.TOMORROW,
+      WidgetValEnums.THIS_WEEK,
+      WidgetValEnums.NEXT_WEEK,
+      WidgetValEnums.THIS_MONTH,
+      WidgetValEnums.NEXT_MONTH,
+      WidgetValEnums.THIS_QUARTER,
+      WidgetValEnums.NEXT_QUARTER,
+      WidgetValEnums.THIS_YEAR,
+      WidgetValEnums.NEXT_YEAR
+    ];
+    options = options.filter(({ value }) => enums.includes(value));
+  }
+  if (optionSetting === WidgetOptionEnums.PAST_TIME) {
+    const enums = [
+      WidgetValEnums.TODAY,
+      WidgetValEnums.YESTERDAY,
+      WidgetValEnums.THIS_WEEK,
+      WidgetValEnums.LAST_WEEK,
+      WidgetValEnums.THIS_MONTH,
+      WidgetValEnums.LAST_MONTH,
+      WidgetValEnums.THIS_QUARTER,
+      WidgetValEnums.LAST_QUARTER,
+      WidgetValEnums.THIS_YEAR,
+      WidgetValEnums.LAST_YEAR
+    ];
+    options = options.filter(({ value }) => enums.includes(value));
+  }
+  return options;
+};
+const generateDefOptionsInApi = (widgetType, mappingConfig = {
+  mappingMethod: null,
+  mapping: []
+}) => {
+  var _a, _b;
+  if (isNil(widgetType))
+    return [];
+  if (widgetType === WidgetTypeEnums.SELECT) {
+    const { mapping } = mappingConfig;
+    return mapping;
+  }
+  return (_b = (_a = widgetValOptions[DataTypeEnums.API]) == null ? void 0 : _a[widgetType]) != null ? _b : [];
+};
+
+export { generateDefOptionsInApi, generateDefOptionsInSql };

package/es/components/table-filter/src/tool/getWidgetType.d.ts

@@ -0,0 +1 @@
+export declare const getWidgetTypeInSql: (fieldType: string, mappingConfig?: any) => string;

package/es/components/table-filter/src/tool/getWidgetType.js

@@ -0,0 +1,27 @@
+import { WidgetTypeEnums, FieldTypeEnums } from '../types/enums.js';
+
+const getWidgetTypeInSql = (fieldType, mappingConfig = {
+  mappingMethod: null,
+  mapping: []
+}) => {
+  switch (fieldType) {
+    case FieldTypeEnums.NUMBER:
+      if (mappingConfig.mappingMethod) {
+        return WidgetTypeEnums.SELECT;
+      }
+      return WidgetTypeEnums.INPUT_NUMBER;
+    case FieldTypeEnums.TEXT:
+      if (mappingConfig.mappingMethod) {
+        return WidgetTypeEnums.SELECT;
+      }
+      return WidgetTypeEnums.INPUT;
+    case FieldTypeEnums.DATE_TIME:
+      return WidgetTypeEnums.DATE_TIME;
+    case FieldTypeEnums.DATE:
+      return WidgetTypeEnums.DATE;
+    default:
+      return WidgetTypeEnums.INPUT;
+  }
+};
+
+export { getWidgetTypeInSql };

package/es/components/table-filter/src/tool/options.d.ts

@@ -0,0 +1,18 @@
+export declare const widgetTypeOptions: {
+    label: string;
+    value: string;
+}[];
+export declare const widgetCfgOptions: {
+    [x: string]: {
+        label: string;
+        value: string;
+    }[];
+};
+export declare const widgetValOptions: {
+    [x: string]: {
+        [x: string]: {
+            label: string;
+            value: string;
+        }[];
+    };
+};

package/es/components/table-filter/src/tool/options.js

@@ -0,0 +1,200 @@
+import { WidgetTypeEnums, WidgetOptionEnums, DataTypeEnums, WidgetValEnums } from '../types/enums.js';
+
+const widgetTypeOptions = [
+  {
+    label: "\u6570\u5B57\u6846",
+    value: WidgetTypeEnums.INPUT_NUMBER
+  },
+  {
+    label: "\u6587\u672C\u6846",
+    value: WidgetTypeEnums.INPUT
+  },
+  {
+    label: "\u4E0B\u62C9\u6846",
+    value: WidgetTypeEnums.SELECT
+  },
+  {
+    label: "\u65E5\u671F\u6846",
+    value: WidgetTypeEnums.DATE
+  },
+  {
+    label: "\u65E5\u671F\u65F6\u95F4\u6846",
+    value: WidgetTypeEnums.DATE_TIME
+  }
+];
+const widgetCfgOptions = {
+  [WidgetTypeEnums.SELECT]: [
+    {
+      label: "\u5355\u9009",
+      value: WidgetOptionEnums.RADIO
+    },
+    {
+      label: "\u591A\u9009",
+      value: WidgetOptionEnums.MULTIPLE
+    }
+  ],
+  [WidgetTypeEnums.DATE_TIME]: [
+    {
+      label: "\u5168\u90E8",
+      value: WidgetOptionEnums.ALL
+    },
+    {
+      label: "\u9009\u62E9\u65F6\u95F4",
+      value: WidgetOptionEnums.SELECT_TIME
+    },
+    {
+      label: "\u8FC7\u53BB\u65F6\u95F4",
+      value: WidgetOptionEnums.PAST_TIME
+    },
+    {
+      label: "\u672A\u6765\u65F6\u95F4",
+      value: WidgetOptionEnums.FUTURE_TIME
+    }
+  ]
+};
+const widgetValOptions = {
+  [DataTypeEnums.API]: {
+    [WidgetTypeEnums.DATE]: [
+      {
+        label: "\u4ECA\u5929",
+        value: WidgetValEnums.TODAY
+      },
+      {
+        label: "\u660E\u5929",
+        value: WidgetValEnums.TOMORROW
+      },
+      {
+        label: "\u6628\u5929",
+        value: WidgetValEnums.YESTERDAY
+      },
+      {
+        label: "\u672C\u5468\u521D",
+        value: WidgetValEnums.WEEK_START
+      },
+      {
+        label: "\u672C\u5468\u672B",
+        value: WidgetValEnums.WEEK_END
+      },
+      {
+        label: "\u672C\u6708\u521D",
+        value: WidgetValEnums.MONTH_START
+      },
+      {
+        label: "\u672C\u6708\u672B",
+        value: WidgetValEnums.MONTH_END
+      }
+    ],
+    [WidgetTypeEnums.DATE_TIME]: [
+      {
+        label: "\u5F53\u524D\u65F6\u95F4",
+        value: WidgetValEnums.NOW
+      },
+      {
+        label: "\u4ECA\u5929\u521D",
+        value: WidgetValEnums.TODAY_START
+      },
+      {
+        label: "\u4ECA\u5929\u672B",
+        value: WidgetValEnums.TODAY_END
+      },
+      {
+        label: "\u6628\u5929\u521D",
+        value: WidgetValEnums.YESTERDAY_START
+      },
+      {
+        label: "\u6628\u5929\u672B",
+        value: WidgetValEnums.YESTERDAY_END
+      },
+      {
+        label: "\u660E\u5929\u521D",
+        value: WidgetValEnums.TOMORROW_START
+      },
+      {
+        label: "\u660E\u5929\u672B",
+        value: WidgetValEnums.TOMORROW_END
+      },
+      {
+        label: "\u672C\u5468\u521D",
+        value: WidgetValEnums.WEEK_START
+      },
+      {
+        label: "\u672C\u5468\u672B",
+        value: WidgetValEnums.WEEK_END
+      },
+      {
+        label: "\u672C\u6708\u521D",
+        value: WidgetValEnums.MONTH_START
+      },
+      {
+        label: "\u672C\u6708\u672B",
+        value: WidgetValEnums.MONTH_END
+      }
+    ]
+  },
+  [DataTypeEnums.SQL]: {
+    [WidgetTypeEnums.DATE_TIME]: [
+      {
+        label: "\u4ECA\u5929",
+        value: WidgetValEnums.TODAY
+      },
+      {
+        label: "\u660E\u5929",
+        value: WidgetValEnums.TOMORROW
+      },
+      {
+        label: "\u6628\u5929",
+        value: WidgetValEnums.YESTERDAY
+      },
+      {
+        label: "\u672C\u5468",
+        value: WidgetValEnums.THIS_WEEK
+      },
+      {
+        label: "\u4E0B\u5468",
+        value: WidgetValEnums.NEXT_WEEK
+      },
+      {
+        label: "\u4E0A\u5468",
+        value: WidgetValEnums.LAST_WEEK
+      },
+      {
+        label: "\u672C\u6708",
+        value: WidgetValEnums.THIS_MONTH
+      },
+      {
+        label: "\u4E0B\u6708",
+        value: WidgetValEnums.NEXT_MONTH
+      },
+      {
+        label: "\u4E0A\u6708",
+        value: WidgetValEnums.LAST_MONTH
+      },
+      {
+        label: "\u672C\u5B63\u5EA6",
+        value: WidgetValEnums.THIS_QUARTER
+      },
+      {
+        label: "\u4E0B\u5B63\u5EA6",
+        value: WidgetValEnums.NEXT_QUARTER
+      },
+      {
+        label: "\u4E0A\u5B63\u5EA6",
+        value: WidgetValEnums.LAST_QUARTER
+      },
+      {
+        label: "\u672C\u5E74",
+        value: WidgetValEnums.THIS_YEAR
+      },
+      {
+        label: "\u4E0B\u5E74",
+        value: WidgetValEnums.NEXT_YEAR
+      },
+      {
+        label: "\u4E0A\u5E74",
+        value: WidgetValEnums.LAST_YEAR
+      }
+    ]
+  }
+};
+
+export { widgetCfgOptions, widgetTypeOptions, widgetValOptions };

package/es/components/table-filter/src/tool/resizeSensor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Class for dimension change detection.
+ *
+ * @param {Element|Element[]} element
+ * @param {Function} callback
+ *
+ * @constructor
+ */
+declare class ResizeSensor {
+    _isCollectionTyped: boolean;
+    _element: any;
+    constructor(element: any, callback: any);
+    static detach(element: any): void;
+    detach(): void;
+}
+export default ResizeSensor;

package/es/components/table-filter/src/tool/resizeSensor.js

@@ -0,0 +1,123 @@
+const requestAnimationFrame = window.requestAnimationFrame || function(fn) {
+  return window.setTimeout(fn, 20);
+};
+class EventQueue {
+  constructor(element) {
+    this.q = [];
+    this.add = function(ev) {
+      this.q.push(ev);
+    };
+    let i;
+    this.call = function() {
+      for (i = 0; i < this.q.length; i++) {
+        this.q[i].call(this, element);
+      }
+    };
+  }
+}
+function getComputedStyle(element, prop) {
+  if (element.currentStyle) {
+    return element.currentStyle[prop];
+  } else if (window.getComputedStyle) {
+    return window.getComputedStyle(element, null).getPropertyValue(prop);
+  } else {
+    return element.style[prop];
+  }
+}
+function attachResizeEvent(element, resized) {
+  if (!element.resizedAttached) {
+    element.resizedAttached = new EventQueue(element);
+    element.resizedAttached.add(resized);
+  } else if (element.resizedAttached) {
+    element.resizedAttached.add(resized);
+    return;
+  }
+  element.resizeSensor = document.createElement("div");
+  element.resizeSensor.className = "resize-sensor";
+  const style = "position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: hidden; z-index: -1; visibility: hidden; opacity: 0;direction: ltr;";
+  const styleChild = "position: absolute; left: 0; top: 0; transition: 0s;";
+  element.resizeSensor.style.cssText = style;
+  element.resizeSensor.innerHTML = '<div class="resize-sensor-expand" style="' + style + '"><div style="' + styleChild + '"></div></div><div class="resize-sensor-shrink" style="' + style + '"><div style="' + styleChild + ' width: 200%; height: 200%"></div></div>';
+  element.appendChild(element.resizeSensor);
+  if (getComputedStyle(element, "position") == "static") {
+    element.style.position = "relative";
+  }
+  const expand = element.resizeSensor.childNodes[0];
+  const expandChild = expand.childNodes[0];
+  const shrink = element.resizeSensor.childNodes[1];
+  const reset = function() {
+    expandChild.style.width = 1e5 + "px";
+    expandChild.style.height = 1e5 + "px";
+    expand.scrollLeft = 1e5;
+    expand.scrollTop = 1e5;
+    shrink.scrollLeft = 1e5;
+    shrink.scrollTop = 1e5;
+  };
+  reset();
+  let dirty = false;
+  const dirtyChecking = function() {
+    if (!element.resizedAttached)
+      return;
+    if (dirty) {
+      element.resizedAttached.call();
+      dirty = false;
+    }
+    requestAnimationFrame(dirtyChecking);
+  };
+  requestAnimationFrame(dirtyChecking);
+  let lastWidth;
+  let lastHeight;
+  let cachedWidth;
+  let cachedHeight;
+  const onScroll = function() {
+    if ((cachedWidth = element.offsetWidth) != lastWidth || (cachedHeight = element.offsetHeight) != lastHeight) {
+      dirty = true;
+      lastWidth = cachedWidth;
+      lastHeight = cachedHeight;
+    }
+    reset();
+  };
+  const addEvent = function(el, name, cb) {
+    if (el.attachEvent) {
+      el.attachEvent("on" + name, cb);
+    } else {
+      el.addEventListener(name, cb);
+    }
+  };
+  addEvent(expand, "scroll", onScroll);
+  addEvent(shrink, "scroll", onScroll);
+}
+class ResizeSensor {
+  constructor(element, callback) {
+    const elementType = Object.prototype.toString.call(element);
+    this._isCollectionTyped = "[object Array]" === elementType || "[object NodeList]" === elementType || "[object HTMLCollection]" === elementType;
+    this._element = element;
+    if (this._isCollectionTyped) {
+      for (let i = 0; i < element.length; i++) {
+        attachResizeEvent(element[i], callback);
+      }
+    } else {
+      attachResizeEvent(element, callback);
+    }
+  }
+  static detach(element) {
+    if (element.resizeSensor) {
+      element.removeChild(element.resizeSensor);
+      delete element.resizeSensor;
+      delete element.resizedAttached;
+    }
+  }
+  detach() {
+    const isCollectionTyped = this._isCollectionTyped;
+    const element = this._element;
+    if (isCollectionTyped) {
+      for (let i = 0; i < element.length; i++) {
+        ResizeSensor.detach(element[i]);
+      }
+    } else {
+      ResizeSensor.detach(element);
+    }
+  }
+}
+
+export { ResizeSensor as default };

package/es/components/table-filter/src/tool/time-domain.d.ts

@@ -0,0 +1,39 @@
+import moment from 'moment';
+declare const timeDomain: {
+    TODAY(): moment.Moment[];
+    TOMORROW(): moment.Moment[];
+    YESTERDAY(): moment.Moment[];
+    THIS_WEEK(): moment.Moment[];
+    NEXT_WEEK(): moment.Moment[];
+    UP_WEEK(): moment.Moment[];
+    THIS_MONTH(): moment.Moment[];
+    NEXT_MONTH(): moment.Moment[];
+    UP_MONTH(): moment.Moment[];
+    THIS_SEASON(): moment.Moment[];
+    NEXT_SEASON(): moment.Moment[];
+    UP_SEASON(): moment.Moment[];
+    THIS_YEAR(): moment.Moment[];
+    UP_YEAR(): moment.Moment[];
+    NEXT_YEAR(): moment.Moment[];
+    getMonth(difference?: number): moment.Moment[];
+    getQuarter(difference?: number): moment.Moment[];
+    getYear(difference?: number): moment.Moment[];
+    /**
+     * 获取前 i 周的周一和周日日期，并以数组的方式返回。
+     * 当 i=1，获取的是上周一和上周日的日期；
+     * 当 i=2，获取的是上上周一和上上周日的日期
+     * ...以此类推
+     * @param i
+     */
+    getLastWeek(i: number): moment.Moment[];
+    /**
+     * 获取后 i 周的周一和周日日期，并以数组的方式返回。
+     * 当 i=1，获取的是下周一和下周日的日期；
+     * 当 i=2，获取的是下下周一和下下周日的日期
+     * ...以此类推
+     * @param i
+     */
+    getNextWeek(i: number): moment.Moment[];
+    getTimeDomain(type: string, format?: string): any;
+};
+export default timeDomain;

package/es/components/table-filter/src/tool/time-domain.js

@@ -0,0 +1,100 @@
+import moment from 'moment';
+
+const timeDomain = {
+  TODAY() {
+    const start = moment().startOf("day");
+    const end = moment().endOf("day");
+    return [start, end];
+  },
+  TOMORROW() {
+    const start = moment().add(1, "days").startOf("days");
+    const end = moment().add(1, "days").endOf("days");
+    return [start, end];
+  },
+  YESTERDAY() {
+    const start = moment().subtract(1, "days").startOf("days");
+    const end = moment().subtract(1, "days").endOf("days");
+    return [start, end];
+  },
+  THIS_WEEK() {
+    const start = moment().startOf("week");
+    const end = moment().endOf("week");
+    return [start, end];
+  },
+  NEXT_WEEK() {
+    return timeDomain.getNextWeek(1);
+  },
+  UP_WEEK() {
+    return timeDomain.getLastWeek(1);
+  },
+  THIS_MONTH() {
+    return timeDomain.getMonth(0);
+  },
+  NEXT_MONTH() {
+    return timeDomain.getMonth(1);
+  },
+  UP_MONTH() {
+    return timeDomain.getMonth(-1);
+  },
+  THIS_SEASON() {
+    return timeDomain.getQuarter(0);
+  },
+  NEXT_SEASON() {
+    return timeDomain.getQuarter(1);
+  },
+  UP_SEASON() {
+    return timeDomain.getQuarter(-1);
+  },
+  THIS_YEAR() {
+    return timeDomain.getYear(0);
+  },
+  UP_YEAR() {
+    return timeDomain.getYear(-1);
+  },
+  NEXT_YEAR() {
+    return timeDomain.getYear(1);
+  },
+  getMonth(difference = 0) {
+    const c_mouth = moment().month() + difference;
+    const start = moment().month(c_mouth).startOf("month");
+    const end = moment().month(c_mouth).endOf("month");
+    return [start, end];
+  },
+  getQuarter(difference = 0) {
+    const c_mouth = moment().quarter() + difference;
+    const start = moment().quarter(c_mouth).startOf("quarter");
+    const end = moment().quarter(c_mouth).endOf("quarter");
+    return [start, end];
+  },
+  getYear(difference = 0) {
+    const c_year = moment().year() + difference;
+    const start = moment().year(c_year).startOf("year");
+    const end = moment().year(c_year).endOf("year");
+    return [start, end];
+  },
+  getLastWeek(i) {
+    const weekOfDay = parseInt(moment().format("E"));
+    const last_monday = moment().subtract(weekOfDay + 7 * i - 1, "days").startOf("days");
+    const last_sunday = moment().subtract(weekOfDay + 7 * (i - 1), "days").endOf("days");
+    return [last_monday, last_sunday];
+  },
+  getNextWeek(i) {
+    const weekOfDay = parseInt(moment().format("E"));
+    const next_monday = moment().add(7 - weekOfDay + 7 * (i - 1) + 1, "days").startOf("days");
+    const next_sunday = moment().add(7 - weekOfDay + 7 * i, "days").endOf("days");
+    return [next_monday, next_sunday];
+  },
+  getTimeDomain(type, format) {
+    if (timeDomain[type]) {
+      const res = timeDomain[type]();
+      if (typeof format === "string") {
+        return res.map((v) => v.format(type));
+      }
+      return res;
+    } else {
+      return [];
+    }
+  }
+};
+
+export { timeDomain as default };

package/es/components/table-filter/src/tool/transformData.d.ts

@@ -0,0 +1,92 @@
+import { IFilterConditionType } from '../../../../../es/components/table-filter/src/types';
+/**
+ * 高级筛选数据转换
+ */
+export declare const transformDataToFront: (dataType: string, rawData?: any[]) => {
+    dataType: string;
+    p_name: any;
+    p_type: any;
+    title: any;
+    customTitle: any;
+    type: any;
+    optionSetting: any;
+    openAdvancedFilter: any;
+    filterOutDisplay: any;
+    filterOutRequired: any;
+    width: any;
+    defValCfg: {
+        value: any;
+        presetVal: any;
+    };
+    mappingConfig: {
+        mappingMethod: null;
+        mapping: any;
+    };
+    remark: any;
+    _rawData: any;
+}[] | {
+    dataType: string;
+    fieldType: any;
+    title: any;
+    customTitle: any;
+    optionSetting: any;
+    openAdvancedFilter: any;
+    filterOutDisplay: any;
+    filterOutRequired: any;
+    width: any;
+    defValCfg: {
+        value: any;
+        presetVal: any;
+    };
+    mappingConfig: {
+        mappingMethod: null;
+        mapping: any;
+    };
+    remark: any;
+    _rawData: any;
+}[];
+export declare const transformDataToEnd: (data: IFilterConditionType[]) => ({
+    name: string | undefined;
+    title: string;
+    customTitle: string;
+    type: any;
+    dataType: string | undefined;
+    isShowSearch: boolean;
+    filterExplicit: boolean;
+    explicitRequired: boolean;
+    width: string | undefined;
+    optionType: string | undefined;
+    defaultValue: {
+        valueList: any[];
+        unit: any;
+    };
+    optionInfo: {
+        manualMapping: any;
+        list: any;
+    };
+    remark: string | undefined;
+} | {
+    name: string | undefined;
+    title: string;
+    customTitle: string;
+    type: string | undefined;
+    dataType: string | undefined;
+    isShowSearch: boolean;
+    filterExplicit: boolean;
+    explicitRequired: boolean;
+    width: string | undefined;
+    optionType: string | undefined;
+    defaultValue: {
+        valueList: any[];
+        unit: any;
+    };
+    optionInfo: any;
+    remark: string | undefined;
+} | null)[];
+export declare const transformConditions: (rawConditions: any, params: any[]) => any;
+export declare const transformRawConditions: (conditions: any[]) => {
+    field_key: any;
+    con: any;
+    value: any;
+    unit: any;
+}[];