linkmore-design 1.0.67 → 1.0.68

package/es/Approval/type.d.ts

@@ -1,24 +1,55 @@
 /// <reference types="react" />
 export declare type VoidFunction = () => void;
+export declare enum ApprovalType {
+    START = "START",
+    APPROVAL = "APPROVAL",
+    CARBON_COPY = "CARBON_COPY",
+    ONLY_COMMENT = "ONLY_COMMENT"
+}
+export declare enum StatusType {
+    AGREE = "AGREE",
+    REFUSE = "REFUSE",
+    PENDING = "PENDING"
+}
+export declare namespace ApprovalType {
+    function isAgree(type: ApprovalType, status: StatusType): boolean;
+    function isPending(type: ApprovalType, status: StatusType): boolean;
+    function isRefuse(type: ApprovalType, status: StatusType): boolean;
+    function isCC(type: ApprovalType): boolean;
+    function isOnlyComment(type: ApprovalType): boolean;
+    function isApproval(type: ApprovalType): boolean;
+    function toText(type: ApprovalType, status: StatusType): "" | "审核中" | "未通过" | "已审核" | "仅评论";
+}
 export interface IApprovalItemProps {
     avator?: string;
     name?: string;
     time?: string;
-    type?: 'start' | 'comment' | 'carbonCopy' | 'agree' | 'refuse' | 'pending';
+    urge?: boolean;
+    type?: ApprovalType;
+    approvalStatus?: StatusType;
     everyoneAgree?: boolean;
-    approverList: Array<string>;
+    approverList?: Array<string>;
+    agreeList?: Array<string>;
+    refuse?: string;
+    carbonCopyList?: Array<string>;
+    isCarbonCopy?: boolean;
+    comment?: string;
     [prop: string]: any;
 }
 export interface IApprovalProps {
     visible?: boolean;
     title?: string;
-    close?: () => void;
     className?: string;
     style?: React.CSSProperties;
-    userType?: 'self' | 'approver';
-    status?: 1 | 2 | 3;
+    proposer: string;
+    user: string;
     steps?: Array<IApprovalItemProps>;
-    onComment: VoidFunction;
-    onRefuse: VoidFunction;
-    onAgree: VoidFunction;
+    onClose?: VoidFunction;
+    onComment?: VoidFunction;
+    onRefuse?: VoidFunction;
+    onAgree?: VoidFunction;
+    onUrge?: (approvalItem: IApprovalItemProps, i: number, list: Array<IApprovalItemProps>) => void;
+    onCarbonCopy?: (approvalItem: IApprovalItemProps, i: number, list: Array<IApprovalItemProps>) => void;
+    onDeleteComment?: (approvalItem: IApprovalItemProps, i: number, list: Array<IApprovalItemProps>) => void;
+    __update?: boolean;
 }

package/es/Approval/type.js

@@ -1 +1,97 @@
-export {};
+// 节点类型
+export var ApprovalType;
+
+(function (ApprovalType) {
+  ApprovalType["START"] = "START";
+  ApprovalType["APPROVAL"] = "APPROVAL";
+  ApprovalType["CARBON_COPY"] = "CARBON_COPY";
+  ApprovalType["ONLY_COMMENT"] = "ONLY_COMMENT";
+})(ApprovalType || (ApprovalType = {}));
+
+export var StatusType;
+
+(function (StatusType) {
+  StatusType["AGREE"] = "AGREE";
+  StatusType["REFUSE"] = "REFUSE";
+  StatusType["PENDING"] = "PENDING";
+})(StatusType || (StatusType = {}));
+
+(function (ApprovalType) {
+  function isAgree(type, status) {
+    if (type === ApprovalType.APPROVAL && status === StatusType.AGREE) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isAgree = isAgree;
+
+  function isPending(type, status) {
+    if (type === ApprovalType.APPROVAL && status === StatusType.PENDING) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isPending = isPending;
+
+  function isRefuse(type, status) {
+    if (type === ApprovalType.APPROVAL && status === StatusType.REFUSE) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isRefuse = isRefuse;
+
+  function isCC(type) {
+    if (type === ApprovalType.CARBON_COPY) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isCC = isCC;
+
+  function isOnlyComment(type) {
+    if (type === ApprovalType.ONLY_COMMENT) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isOnlyComment = isOnlyComment;
+
+  function isApproval(type) {
+    if (type === ApprovalType.APPROVAL) {
+      return true;
+    }
+
+    return false;
+  }
+
+  ApprovalType.isApproval = isApproval;
+
+  function toText(type, status) {
+    if (type === ApprovalType.APPROVAL) {
+      if (status === StatusType.PENDING) {
+        return '审核中';
+      } else if (status === StatusType.REFUSE) {
+        return '未通过';
+      } else if (status === StatusType.AGREE) {
+        return '已审核';
+      }
+    } else if (type === ApprovalType.ONLY_COMMENT) {
+      return '仅评论';
+    }
+
+    return '';
+  }
+
+  ApprovalType.toText = toText;
+})(ApprovalType || (ApprovalType = {}));

package/es/Approval/util.d.ts

@@ -0,0 +1,26 @@
+import { IApprovalItemProps, StatusType } from "./type";
+/**
+ * 当前用户是否可以审批
+ * @param steps
+ * @param user
+ */
+export declare function currentUserIsApprover(steps: Array<IApprovalItemProps>, user: string): boolean;
+/**
+ * 当前用户是否是提议发起者
+ * @param proposer
+ * @param user
+ */
+export declare function currentUserIsProposer(proposer: string, user: string): boolean;
+/**
+ * 审批节点是否通过
+ * @param approverList 审批人列表
+ * @param agreeList 已通过列表
+ * @param everyoneAgree 是否需要所有人都通过
+ */
+export declare function isAgreeOfApproverNode(approverList: Array<string>, agreeList: Array<string>, everyoneAgree: boolean): boolean;
+/**
+ * 获取当前审批单状态
+ * @param steps
+ * @returns
+ */
+export declare function getStatus(steps: Array<IApprovalItemProps>): StatusType;

package/es/Approval/util.js

@@ -0,0 +1,132 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { ApprovalType, StatusType } from "./type";
+/**
+ * 当前用户是否可以审批
+ * @param steps
+ * @param user
+ */
+
+export function currentUserIsApprover(steps, user) {
+  var _iterator = _createForOfIteratorHelper(steps),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var step = _step.value;
+
+      // 审核中
+      if (ApprovalType.isPending(step.type, step.approvalStatus)) {
+        if (step.everyoneAgree) {
+          var index = step.agreeList.length;
+
+          if (index < step.approverList.length && step.approverList[index] === user) {
+            return true;
+          }
+        } else {
+          if (step.approverList.indexOf(user) !== -1) {
+            return true;
+          }
+        }
+
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return false;
+}
+/**
+ * 当前用户是否是提议发起者
+ * @param proposer
+ * @param user
+ */
+
+export function currentUserIsProposer(proposer, user) {
+  return proposer && proposer === user;
+}
+/**
+ * 审批节点是否通过
+ * @param approverList 审批人列表
+ * @param agreeList 已通过列表
+ * @param everyoneAgree 是否需要所有人都通过
+ */
+
+export function isAgreeOfApproverNode(approverList, agreeList, everyoneAgree) {
+  if (!approverList.length) {
+    return false;
+  }
+
+  if (everyoneAgree) {
+    var _iterator2 = _createForOfIteratorHelper(approverList),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var value = _step2.value;
+
+        if (agreeList.indexOf(value) === -1) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return true;
+  } else {
+    var _iterator3 = _createForOfIteratorHelper(agreeList),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _value = _step3.value;
+
+        if (approverList.indexOf(_value) !== -1) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    return false;
+  }
+}
+/**
+ * 获取当前审批单状态
+ * @param steps
+ * @returns
+ */
+
+export function getStatus(steps) {
+  var _iterator4 = _createForOfIteratorHelper(steps),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var step = _step4.value;
+
+      if (ApprovalType.isPending(step.type, step.approvalStatus)) {
+        return StatusType.PENDING;
+      }
+
+      if (ApprovalType.isRefuse(step.type, step.approvalStatus)) {
+        return StatusType.REFUSE;
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  return StatusType.AGREE;
+}

package/es/AutoComplete/index.d.ts

@@ -10,6 +10,7 @@ import * as React from 'react';
 import type { BaseOptionType, DefaultOptionType, InternalSelectProps } from 'antd/es/select';
 import type { InputStatus } from '../_util/statusUtils';
 import { AutoComplete as AntdAutoComplete } from 'antd';
+declare const Option: import("rc-select/lib/Option").OptionFC;
 export interface DataSourceItemObject {
     value: string;
     text: string;
@@ -24,7 +25,7 @@ declare const RefAutoComplete: (<ValueType = any, OptionType extends DefaultOpti
 } & {
     ref?: React.Ref<BaseSelectRef>;
 }) => React.ReactElement) & {
-    Option: import("rc-select/lib/Option").OptionFC;
+    Option: typeof Option;
     AntdAutoComplete: typeof AntdAutoComplete;
 };
 export default RefAutoComplete;

package/es/Calendar/index.d.ts

@@ -0,0 +1,4 @@
+import { Calendar } from 'antd';
+export type { CalendarProps } from 'antd';
+export type { CalendarMode } from 'antd/es/calendar/generateCalendar';
+export default Calendar;

package/es/Calendar/index.js

@@ -0,0 +1,3 @@
+import "antd/es/calendar/style";
+import _Calendar from "antd/es/calendar";
+export default _Calendar;