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

package/es/components/table-filter/src/directive/flexibleResize.d.ts

@@ -0,0 +1,28 @@
+import { IFlexibleType } from '../../../../../es/components/table-filter/src/types/tool';
+export declare class FlexibleResize {
+    options: IFlexibleType;
+    tool: any;
+    mask: any;
+    _elPosition: any;
+    _isV: boolean;
+    _ms: number;
+    _mv: number;
+    constructor(options: IFlexibleType);
+    init(options: IFlexibleType): void;
+    destroyed(): void;
+    initElPosition(): void;
+    maskCreate(mode: string): any;
+    maskRemove(): void;
+    maskMove: (e: any) => void;
+    maskUp: (e: any) => void;
+    maskInsert(): any;
+    toolCreate(): any;
+    toolRemove(): void;
+    toolInitStyle(): void;
+    toolDown: (e: any) => void;
+}
+declare const _default: {
+    mounted(el: any, { value }: any): void;
+    beforeUnmount(el: any): void;
+};
+export default _default;

package/es/components/table-filter/src/directive/flexibleResize.js

@@ -0,0 +1,157 @@
+class FlexibleResize {
+  constructor(options) {
+    this.maskMove = (e) => {
+      const v = this._isV ? e.screenX : e.screenY;
+      const distance = v - this._mv;
+      this._mv = v;
+      const { onMove } = this.options;
+      onMove && onMove({
+        evt: e,
+        distance
+      });
+    };
+    this.maskUp = (e) => {
+      const { onEnd } = this.options;
+      const v = this._isV ? e.screenX : e.screenY;
+      onEnd && onEnd({
+        evt: e,
+        distance: v - this._ms
+      });
+      this.maskRemove();
+    };
+    this.toolDown = (e) => {
+      this.maskInsert();
+      this._isV = /^V/.test(this.options.mode);
+      this._ms = this._mv = this._isV ? e.screenX : e.screenY;
+      const { onStart } = this.options;
+      onStart && onStart({
+        evt: e,
+        distance: 0
+      });
+    };
+    this.options = options || {};
+    this.tool = null;
+    this.mask = null;
+    this._elPosition = null;
+    this._isV = false;
+    this._ms = 0;
+    this._mv = 0;
+    this.init(options);
+  }
+  init(options) {
+    const { el } = options;
+    if (!el)
+      return;
+    const tool = this.toolCreate();
+    this.initElPosition();
+    el.appendChild(tool);
+  }
+  destroyed() {
+    const { el } = this.options;
+    this.maskRemove();
+    this.toolRemove();
+    if (this._elPosition) {
+      el.style.setProperty("position", this._elPosition);
+    } else {
+      el.style.removeProperty("position");
+    }
+  }
+  initElPosition() {
+    const el = this.options.el;
+    if (!el)
+      return;
+    this._elPosition = el.style.position;
+    const defStyle = window.getComputedStyle(el, null);
+    const position = defStyle.position;
+    if (!position || position === "static") {
+      el.style.setProperty("position", "relative");
+    }
+  }
+  maskCreate(mode) {
+    if (this.mask)
+      return this.mask;
+    const mask = document.createElement("div");
+    mask.style = "position:fixed;top:0;bottom:0;left:0;right:0;z-index:99999;cursor:" + (/^V/.test(mode) ? "col" : "row") + "-resize";
+    mask.addEventListener("mousemove", this.maskMove);
+    mask.addEventListener("mouseup", this.maskUp);
+    this.mask = mask;
+    return mask;
+  }
+  maskRemove() {
+    const mask = this.mask;
+    if (!mask)
+      return;
+    mask.parentNode && mask.parentNode.removeChild(mask);
+    mask.removeEventListener("mousemove", this.maskMove);
+    mask.removeEventListener("mouseup", this.maskUp);
+    this.mask = null;
+  }
+  maskInsert() {
+    const mask = this.mask || this.maskCreate(this.options.mode);
+    document.body.appendChild(mask);
+    return mask;
+  }
+  toolCreate() {
+    if (this.tool)
+      return this.tool;
+    const div = document.createElement("div");
+    div.addEventListener("mousedown", this.toolDown);
+    this.tool = div;
+    this.toolInitStyle();
+    return div;
+  }
+  toolRemove() {
+    const tool = this.tool;
+    if (!tool)
+      return;
+    tool.parentNode && tool.parentNode.removeChild(tool);
+    this.tool = null;
+  }
+  toolInitStyle() {
+    let style = "user-select:none;cursor:col-resize;position:absolute;";
+    const mode = this.options.mode;
+    if (/^V/.test(mode)) {
+      style += "width: 8px;cursor:col-resize;";
+    } else {
+      style += "height: 8px;cursor:row-resize;";
+    }
+    const keys = {
+      VR: "left",
+      VL: "right",
+      HT: "bottom",
+      HB: "top"
+    };
+    const mk = keys[mode];
+    const p = Object.keys(keys).reduce((v, k) => {
+      const value = keys[k];
+      if (value !== mk) {
+        v += `${value}:0;`;
+      }
+      return v;
+    }, "");
+    style += p;
+    if (this.tool) {
+      this.tool.style = style;
+    }
+  }
+}
+var vFlexibleResize = {
+  mounted(el, { value }) {
+    if (el._flexibleResize)
+      return;
+    el._flexibleResize = new FlexibleResize({
+      el,
+      mode: value.mode || "VR",
+      onMove: value.onMove,
+      onEnd: value.onEnd
+    });
+  },
+  beforeUnmount(el) {
+    if (el._flexibleResize) {
+      el._flexibleResize.destroyed();
+      el._flexibleResize = void 0;
+    }
+  }
+};
+
+export { FlexibleResize, vFlexibleResize as default };

package/es/components/table-filter/src/directive/preventReClick.d.ts

@@ -0,0 +1,4 @@
+declare const PreventReClick: {
+    mounted(el: any, binding: any): void;
+};
+export default PreventReClick;

package/es/components/table-filter/src/directive/preventReClick.js

@@ -0,0 +1,14 @@
+const PreventReClick = {
+  mounted(el, binding) {
+    el.addEventListener("click", () => {
+      if (!el.disabled) {
+        el.disabled = true;
+        setTimeout(() => {
+          el.disabled = false;
+        }, binding.value || 1e3);
+      }
+    });
+  }
+};
+
+export { PreventReClick as default };

package/es/components/table-filter/src/directive/resize.d.ts

@@ -0,0 +1,4 @@
+declare const Resize: {
+    mounted(el: any, binding: any): void;
+};
+export default Resize;

package/es/components/table-filter/src/directive/resize.js

@@ -0,0 +1,12 @@
+import ResizeSensor from '../tool/resizeSensor.js';
+import { useDebounceFn } from '@vueuse/core';
+
+const Resize = {
+  mounted(el, binding) {
+    const handler = binding.value;
+    const callback = useDebounceFn(handler, 10);
+    new ResizeSensor(el, callback);
+  }
+};
+
+export { Resize as default };

package/es/components/table-filter/src/hooks/export.d.ts

@@ -0,0 +1 @@
+export * from './useAdvanced';

package/es/components/table-filter/src/hooks/export.js

@@ -0,0 +1 @@
+export { useAdvanced } from './useAdvanced.js';

package/es/components/table-filter/src/hooks/useAdvanced.d.ts

@@ -0,0 +1,28 @@
+import { IApiServerType } from '../../../../../es/components/table-filter/src/types';
+export declare function useAdvanced(): {
+    transformData: (advancedFilterData: IApiServerType[]) => {
+        fieldType: string;
+        columnName: string;
+        settingObj: {};
+        setting: string;
+        widgetCfg: {
+            isRender: boolean;
+            widgetType: string | null;
+            valueList: {
+                value: any;
+                label: string;
+            }[] | undefined;
+            defaultValue: any;
+            defValueUnit: any;
+            multiple: boolean;
+        };
+        title: string;
+        alias: string | undefined;
+        isShowSearch: number;
+        filterExplicit: number;
+        explicitRequired: number;
+        advanceOptionSetting: string;
+        placeholder: string;
+        advanceColWidth: number | null | undefined;
+    }[];
+};

package/es/components/table-filter/src/hooks/useAdvanced.js

@@ -0,0 +1,64 @@
+import { WidgetOptionEnums, WidgetTypeEnums } from '../types/enums.js';
+
+const advanceOptionSettingMap = {
+  [WidgetOptionEnums.RADIO]: "0",
+  [WidgetOptionEnums.MULTIPLE]: "1",
+  [WidgetOptionEnums.ALL]: "0",
+  [WidgetOptionEnums.SELECT_TIME]: "1",
+  [WidgetOptionEnums.PAST_TIME]: "2",
+  [WidgetOptionEnums.FUTURE_TIME]: "3"
+};
+function useAdvanced() {
+  function transformDataToFieldCfg(advancedFilterCfg) {
+    return {
+      title: advancedFilterCfg.title,
+      alias: advancedFilterCfg.customTitle,
+      isShowSearch: advancedFilterCfg.isShowSearch ? 1 : 0,
+      filterExplicit: advancedFilterCfg.filterExplicit ? 1 : 0,
+      explicitRequired: advancedFilterCfg.explicitRequired ? 1 : 0,
+      advanceOptionSetting: advanceOptionSettingMap[advancedFilterCfg.optionType],
+      placeholder: advancedFilterCfg.remark,
+      advanceColWidth: advancedFilterCfg.width
+    };
+  }
+  function transformData(advancedFilterData) {
+    return advancedFilterData.map((item) => {
+      var _a, _b;
+      const { optionInfo = { list: [] }, type, defaultValue, optionType, filterExplicit } = item;
+      const settingObj = {};
+      const cfg = transformDataToFieldCfg(item);
+      let defVal;
+      let defValUnit;
+      let widgetType = type;
+      if (filterExplicit) {
+        defVal = type === WidgetTypeEnums.SELECT && optionType === WidgetOptionEnums.MULTIPLE ? defaultValue == null ? void 0 : defaultValue.valueList : (_a = defaultValue == null ? void 0 : defaultValue.valueList) == null ? void 0 : _a[0];
+        defValUnit = defaultValue == null ? void 0 : defaultValue.unit;
+      } else {
+        if (type === WidgetTypeEnums.SELECT && (optionInfo == null ? void 0 : optionInfo.list) && (optionInfo == null ? void 0 : optionInfo.list.length) < 10) {
+          widgetType = "CHECKBOX_GROUP";
+        }
+      }
+      const widgetCfg = {
+        isRender: true,
+        widgetType,
+        valueList: (_b = optionInfo == null ? void 0 : optionInfo.list) == null ? void 0 : _b.map(({ name, value }) => ({ value, label: name })),
+        defaultValue: defVal,
+        defValueUnit: defValUnit,
+        multiple: optionType === WidgetOptionEnums.MULTIPLE
+      };
+      return {
+        ...cfg,
+        fieldType: item.dataType,
+        columnName: item.name,
+        settingObj,
+        setting: JSON.stringify(settingObj),
+        widgetCfg
+      };
+    });
+  }
+  return {
+    transformData
+  };
+}
+
+export { useAdvanced };

package/es/components/table-filter/src/hooks/useMixins.d.ts

@@ -0,0 +1,60 @@
+import { ISearchType, IbtnType } from '../../../../../es/components/table-filter/src/types';
+export default function (): {
+    filterApiConfig: import("vue").Ref<{}>;
+    handleGetConfigApi: (params: any, key: string, config: {} | undefined, filterApiConfigVal: any) => Promise<any>;
+    $utils: {
+        /**
+         * 获取按钮自定义颜色
+         * @param {string} v
+         */
+        getBtnStyle(v: IbtnType): {
+            'border-color': string;
+            color: string;
+            'background-color'?: undefined;
+        } | {
+            color: string;
+            'border-color'?: undefined;
+            'background-color'?: undefined;
+        } | {
+            'background-color': string;
+            'border-color': string;
+            color?: undefined;
+        };
+        /**
+         * @param: 获取按钮的操作对象
+         * @param {Object} row 行对象
+         * @param {Object} btn 按钮
+         */
+        getRowOperatorIdSetting(row: any, btn: IbtnType): any;
+        getAlphafloat(a: any, alpha?: any): number;
+        hexToRGBA(hex: string, alpha?: any): "" | {
+            r: any;
+            g: any;
+            b: any;
+            a: number;
+        };
+        handleLabelColor(item: any, isSelect: boolean): {
+            color: string;
+            background: string;
+            borderColor: string;
+        };
+        /**
+         *
+         * 时间转换
+         * @param {type} type 时间戳类型
+         * @param {time} time 时间戳
+         */
+        formatTime(type: string, time: any): string;
+        isJSON(str: any): boolean;
+        isArray(val: any): boolean;
+        isEmpty(val: any): boolean;
+        isString(val: any): boolean;
+        isPlainObject(val: any): boolean;
+    };
+    outQuickSearchFn: {
+        handleRequestedLabel(v: any): Promise<import("axios").AxiosResponse<any, any>>;
+        handlerInitSearchItem(arr: ISearchType[], searchFieldLimit?: any): void;
+        handleSetLabelOptions(labelType: any, el: ISearchType): void;
+        getConObj(arr: any): any;
+    };
+};