@lingxiteam/ebe-utils 0.0.10 → 0.0.12

package/lib/h5public/src/utils/LcdpSpin/index.tsx

@@ -2,8 +2,20 @@ import { DotLoading, type DotLoadingProps } from 'antd-mobile-5';
 import React from 'react';
 import './index.less';
 
-const LcdpSpin: React.FC<DotLoadingProps> = (props) => (
-  <DotLoading {...props} className="lcdp-dynamicPage-spinning-mask" />
-);
+interface LcdpSpinProps extends DotLoadingProps {
+  spinning: boolean;
+}
+
+const LcdpSpin: React.FC<LcdpSpinProps> = (props) => {
+  const { spinning = true, ...restProps } = props;
+
+  if (!spinning) {
+    return null;
+  }
+
+  return (
+    <DotLoading {...restProps} className="lcdp-dynamicPage-spinning-mask" />
+  );
+};
 
 export default LcdpSpin;

package/lib/h5public/src/utils/formUtils.ts

@@ -0,0 +1,336 @@
+import { RefsManager } from '@/utils/Context/context';
+
+type RefsType = Record<string, any>;
+
+export const formSubmit = async (form: RefsType, isFormList?: boolean) =>
+  new Promise((resolve, reject) => {
+    form.submit(resolve, reject, isFormList);
+  });
+
+export const formCodeSubmit = async (form: Record<string, any>) =>
+  new Promise(form.submitByCode);
+
+export const getFieldsValueByCode = (form: Record<string, any>) =>
+  new Promise(form.getFieldsValueByCode);
+
+/**
+ * 通过组件id获取所有的组件
+ * @param options
+ * @returns
+ */
+export const getComponentsByCompId = (options: {
+  compId: string;
+  refs: RefsType;
+}) => {
+  const { refs, compId } = options;
+  return Object.keys(refs)
+    .filter((uid) => refs[uid]?.compId === compId)
+    .map((uid) => refs[uid]);
+};
+
+/**
+ * 通过业务组件id获取表单列表
+ * @param engineRelation
+ * @param routerId
+ * @param uid
+ * @returns
+ */
+export const getFormsByBoframerId = (options: {
+  renderRefs: RefsManager;
+  compId: string;
+  refs: RefsType;
+}) => {
+  const { renderRefs, compId, refs } = options;
+  const boframerUids = Object.keys(refs).filter(
+    (id) => refs[id].compId === compId,
+  );
+
+  // 如果没找到组件，就返回null
+  if (!boframerUids.length) {
+    return [];
+  }
+
+  const forms: RefsType[] = [];
+  const getAllForms = (refs: RefsType | null) => {
+    Object.keys(refs || {}).forEach((uid) => {
+      // const engineRef = engineRelation.getEngineRefsByUid(uid, routerId);
+      const renderId = uid;
+      if (renderId) {
+        const engineRefs = renderRefs.getComRefs(renderId);
+        if (engineRefs) {
+          Object.keys(engineRefs).forEach((compUid) => {
+            const r = engineRefs[compUid];
+            getAllForms(r);
+            if (r.compName === 'Form' && !r.isFormList) {
+              forms.push(r);
+            }
+          });
+        }
+      }
+    });
+  };
+
+  getAllForms(
+    boframerUids.reduce((pre, uid) => {
+      pre[uid] = refs[uid];
+      return pre;
+    }, {} as RefsType),
+  );
+
+  return forms;
+};
+
+/**
+ * 通过内部组件内的表单列表获取表单值
+ * @param forms
+ * @param getFieldsValue
+ * FIXME: 若需要兼容表单切套在循环列表的情况，可以修改本方法
+ */
+export const getBoframerValueByForms = async (forms: RefsType[] = []) => {
+  const errorValues: Record<string, any> = {};
+
+  try {
+    const values = await Promise.all(forms.map((form) => formSubmit(form)));
+    return values.reduce((pre, item) => Object.assign(pre as any, item), {});
+  } catch (error) {
+    const { errorFields, values } = (error || {}) as any;
+    if (Array.isArray(errorFields)) {
+      return {
+        errorFields: [...(errorValues.errorFields || []), ...errorFields],
+        values: {
+          ...(errorValues.values || {}),
+          ...(values || {}),
+        },
+      };
+    }
+  }
+};
+
+/**
+ * 通过表单列表获取表单值
+ * @param forms
+ * @param getFieldsValue
+ * FIXME: 若需要兼容表单切套在循环列表的情况，可以修改本方法
+ */
+export const getFormsValueByForms = async (forms: RefsType[] = []) => {
+  const errorValues: Record<string, any> = {};
+
+  try {
+    const values = await Promise.all(forms.map((form) => formSubmit(form)));
+    return values.reduce((pre, item) => Object.assign(pre as any, item), {});
+  } catch (error) {
+    const { errorFields, values } = (error || {}) as any;
+    if (Array.isArray(errorFields)) {
+      return {
+        errorFields: [...(errorValues.errorFields || []), ...errorFields],
+        values: {
+          ...(errorValues.values || {}),
+          ...(values || {}),
+        },
+      };
+    }
+  }
+};
+
+/**
+ * 通过业务组件id获取表单值，
+ * 注：所有表单的值不走formCode逻辑。 若同一个业务组件中多个表单则将所有表单放到一起
+ * @param options
+ * @returns
+ */
+export const getFormValueByBOFramerId = async (options: {
+  refs: RefsType;
+  renderRefs: RefsManager;
+  compId: string;
+}) => {
+  const forms = getFormsByBoframerId(options);
+  return getBoframerValueByForms(forms);
+};
+
+/**
+ * 通过表单id 获取表单值
+ * @param options
+ * @returns
+ */
+export const getFormValueByFormId = async (options: {
+  refs: RefsType;
+  compId: string;
+}) => {
+  const { compId, refs } = options;
+  const formUids = Object.keys(refs).filter((id) => refs[id].compId === compId);
+
+  // 如果没找到组件，就返回null
+  if (!formUids.length) {
+    return [];
+  }
+
+  return getFormsValueByForms(formUids.map((uid) => refs[uid]));
+};
+
+/**
+ * 通过组件名 获取所有表单
+ * @param options
+ * @returns
+ */
+export const getFormsByCompName = (
+  options: {
+    refs: RefsType;
+    renderRefs: RefsManager;
+  },
+  forms: any[] = [],
+) => {
+  const { refs, renderRefs } = options;
+
+  Object.keys(refs).forEach((uid) => {
+    const item = refs[uid];
+    if (!item) return;
+    if (item.compName === 'DForm') {
+      forms.push(item);
+    }
+    if (['Pageview', 'BOFramer'].includes(item.compName)) {
+      getFormsByCompName(renderRefs.getComRefs(uid));
+    }
+  });
+
+  return forms;
+};
+
+/**
+ * 校验并获取表单值
+ */
+export const validateFields = async (
+  options: {
+    refs: RefsType;
+    renderRefs: RefsManager;
+  },
+  getFormValue: (form: Record<string, any>) => Promise<any>,
+) => {
+  const forms = getFormsByCompName(options);
+  const actions: any = forms.map(getFormValue);
+  const formValues: any = {};
+  const values = await Promise.all(actions);
+  values.forEach((val = {}) => {
+    Object.keys(val || {}).forEach((key) => {
+      const isIncludesKey = Object.keys(formValues).includes(key);
+      if (isIncludesKey) {
+        Object.assign(formValues[key], { ...(val[key] || {}) });
+      } else {
+        Object.assign(formValues, { [key]: val[key] });
+      }
+    });
+  });
+  return values;
+};
+
+// // eslint-disable-next-line max-len
+// export const formSubmit = async (form: { submit: (arg0: (value: unknown) => void, arg1: (reason?: any) => void, arg2: any) => void; }, isFormList?: boolean) =>
+//   new Promise((resolve, reject) => {
+//     form.submit(resolve, reject, isFormList);
+//   });
+
+// const collectFomrms = (engineRelation: EngineRelationMethods, forms: any[], routerId: string, refs: any) => {
+//   Object.keys(refs)?.forEach((key) => {
+//     const comRef = refs[key];
+//     if (
+//       comRef?.compName === 'DForm' &&
+//             typeof comRef.submit === 'function' &&
+//             !comRef?.isFormList
+//     ) {
+//       forms.push(comRef);
+//     } else if (comRef?.compName === 'Pageview' || comRef?.compName === 'BOFramer') {
+//       const subRefs = engineRelation.getEngineRefsByUid(key, routerId)?.refs;
+//       if (subRefs) {
+//         collectFomrms(engineRelation, forms, routerId, subRefs);
+//       }
+//     }
+//   });
+// };
+// export const getBOFramerForms = (engineRelation: EngineRelationMethods, routerId: string, uid: string) => {
+//   const boframerRef = engineRelation.getEngineRefsByUid(uid, routerId)?.refs;
+//   const forms: any[] = [];
+//   collectFomrms(engineRelation, forms, routerId, boframerRef);
+//   return forms;
+// };
+
+// // eslint-disable-next-line max-len
+// export const boFramersubmit = async (onSuccess: (arg0: {}) => void, onFail: (arg0: {}) => void, engineRelation: EngineRelationMethods, routerId: string, uid: string) => {
+//   const forms = getBOFramerForms(engineRelation, routerId, uid);
+//   const formValues = {};
+//   const errorValues: Record<string, any> = {};
+//   // eslint-disable-next-line no-plusplus
+//   for (let index = 0; index < forms.length; index++) {
+//     const inForm = forms[index];
+//     try {
+//       const values = await formSubmit(inForm);
+//       Object.assign(formValues, values);
+//     } catch (error) {
+//       const { errorFields, values } = (error || {}) as any;
+//       if (Array.isArray(errorFields)) {
+//         errorValues.errorFields = [
+//           ...(errorValues.errorFields || []),
+//           ...errorFields,
+//         ];
+//         errorValues.values = {
+//           ...(errorValues.values || {}),
+//           ...(values || {}),
+//         };
+//       }
+//     }
+//   }
+//   if (Object.keys(errorValues).length > 0) {
+//     onFail(errorValues);
+//     return;
+//   }
+//   onSuccess(formValues);
+// };
+
+// export const boFramerResetFields = (engineRelation: EngineRelationMethods, routerId: string, uid: string) => {
+//   const forms = getBOFramerForms(engineRelation, routerId, uid);
+//   forms.forEach(form => {
+//     form?.resetFields();
+//   });
+// };
+
+// export const boFramerSetFieldsValue = (engineRelation: EngineRelationMethods, routerId: string, uid: string, v: any) =>
+//   getBOFramerForms(engineRelation, routerId, uid)?.forEach(form => {
+//     form?.setFieldsValue(v);
+//   });
+
+// // eslint-disable-next-line max-len
+// export const boFramerGetFieldsValue = async (onSuccess: (arg0: {}) => void, onFail: (arg0: {}) => void, engineRelation: EngineRelationMethods, routerId: string, uid: string,) => {
+//   const forms = getBOFramerForms(engineRelation, routerId, uid);
+//   const formValues = {};
+//   const errorValues: Record<string, any> = {};
+//   // eslint-disable-next-line no-plusplus
+//   for (let index = 0; index < forms.length; index++) {
+//     const inForm = forms[index];
+//     let errs: any = {};
+//     try {
+//       const values = await inForm.getFieldsValue();
+//       Object.assign(formValues, values);
+//     } catch (error) {
+//       errs = error;
+//     } finally {
+//       const { errorFields, values } = errs;
+//       if (Array.isArray(errorFields)) {
+//         errorValues.errorFields = [
+//           ...(errorValues.errorFields || []),
+//           ...errorFields,
+//         ];
+//         errorValues.values = {
+//           ...(errorValues.values || {}),
+//           ...(values || {}),
+//         };
+//       }
+//     }
+//   }
+//   if (Object.keys(errorValues).length > 0) {
+//     onFail(errorValues);
+//     return;
+//   }
+//   onSuccess(formValues);
+// };
+
+// export const boFramerSetDisabled = (engineRelation: EngineRelationMethods, routerId: string, uid: string, v: any) => {
+//   return getBOFramerForms(engineRelation, routerId, uid).forEach(form => form?.setDisabled(v));
+// };

package/lib/node/babel/getAllImportFiles.d.ts

@@ -1 +1 @@
-export declare const getAllImportFiles: (target: string, allImportFiles?: any) => any;
+export declare const getAllImportFiles: (cwd: string, target: string, allImportFiles?: any) => any;

package/lib/node/babel/getAllImportFiles.js

@@ -37,7 +37,7 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_getRealPath = require("./getRealPath");
 var import_parse = require("./parse");
-var getAllImportFiles = (target, allImportFiles = {}) => {
+var getAllImportFiles = (cwd, target, allImportFiles = {}) => {
   var _a;
   if (!(0, import_fs.existsSync)(target)) {
     return allImportFiles;
@@ -53,12 +53,12 @@ var getAllImportFiles = (target, allImportFiles = {}) => {
     if (isAlias || isRelative) {
       let nextPath = (0, import_path.resolve)((0, import_path.dirname)(target), importName);
       if (isAlias) {
-        nextPath = importName.replace("@/", `${process.cwd()}/src/`);
+        nextPath = importName.replace("@/", `${cwd}/src/`);
       }
       let nextTarget = (0, import_getRealPath.getRealPath)(nextPath);
       if (!allImportFiles[nextTarget]) {
         allImportFiles[nextTarget] = true;
-        getAllImportFiles(nextTarget, allImportFiles);
+        getAllImportFiles(cwd, nextTarget, allImportFiles);
       }
     }
   };

package/lib/node/move.d.ts

@@ -1,5 +1,6 @@
 export interface MoveConfig {
     target: string;
     outDir: string;
+    cwd?: string;
 }
 export declare function move(moveConfig: MoveConfig): Promise<any>;

package/lib/node/move.js

@@ -25,25 +25,24 @@ module.exports = __toCommonJS(move_exports);
 var import_fs_extra = require("fs-extra");
 var import_path = require("path");
 var import_getAllImportFiles = require("./babel/getAllImportFiles");
-var copyFileSyncAlias = (from, to) => {
+var copyFileSyncAlias = (cwd, from, to) => {
   var _a;
   let context = (0, import_fs_extra.readFileSync)(from, "utf-8");
   const importList = ((_a = context.match(/from '@\/([^']+)'/g)) == null ? void 0 : _a.map((match) => match.slice(8, -1))) || [];
   importList.forEach((source) => {
-    const absolute = (0, import_path.join)(process.cwd(), "src", source);
+    const absolute = (0, import_path.join)(cwd, "src", source);
     const filePath = (0, import_path.relative)((0, import_path.dirname)(from), absolute);
     context = context.replace(`@/${source}`, filePath);
   });
   (0, import_fs_extra.writeFileSync)(to, context, "utf-8");
 };
 async function move(moveConfig) {
-  const { target, outDir } = moveConfig;
-  const cwd = process.cwd();
+  const { target, outDir, cwd = process.cwd() } = moveConfig;
   const resolvedTarget = (0, import_path.isAbsolute)(target) ? target : (0, import_path.join)(cwd, target);
   if (!(0, import_fs_extra.existsSync)(resolvedTarget)) {
-    throw new Error(`指定的文件不存在: ${resolvedTarget}`);
+    throw new Error(`指定的入口文件不存在: ${resolvedTarget}`);
   }
-  const allImportFiles = (0, import_getAllImportFiles.getAllImportFiles)(resolvedTarget);
+  const allImportFiles = (0, import_getAllImportFiles.getAllImportFiles)(cwd, resolvedTarget);
   allImportFiles[resolvedTarget] = true;
   const keys = Object.keys(allImportFiles);
   let count = keys.length;
@@ -54,11 +53,23 @@ async function move(moveConfig) {
       return;
     }
     const filePath = (0, import_path.relative)(cwd, file);
-    const absTarget = (0, import_path.join)(cwd, outDir, filePath);
+    const absTarget = (0, import_path.isAbsolute)(outDir) ? (0, import_path.join)(outDir, filePath) : (0, import_path.join)(cwd, outDir, filePath);
     (0, import_fs_extra.mkdirpSync)((0, import_path.dirname)(absTarget));
-    copyFileSyncAlias(file, absTarget);
+    copyFileSyncAlias(cwd, file, absTarget);
   });
   console.log(`[COPY] 共拷贝文件数 ${count}`);
+  const pkg = (0, import_path.join)(cwd, "package.json");
+  if ((0, import_fs_extra.existsSync)(pkg)) {
+    let context = (0, import_fs_extra.readJSONSync)(pkg, "utf-8");
+    (0, import_fs_extra.writeJSONSync)(
+      (0, import_path.join)(outDir, "package.json"),
+      {
+        name: context.name,
+        version: context.version
+      },
+      "utf-8"
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/pcpublic/src/components/common/PreviewFile/index.less

@@ -0,0 +1,200 @@
+@import (reference) '../../../styles/index.less';
+
+@prefixCls: lcdp-previewFile;
+
+.@{prefixCls}-wrapPic {
+  display: flex;
+  align-items: center;
+  /*垂直居中*/
+  justify-content: center;
+  /*水平居中*/
+  height: auto !important;
+}
+
+.@{prefixCls}-wrap {
+  display: flex;
+  flex: 1;
+  align-items: center;
+  flex-direction: column;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  overflow: auto;
+
+  .content {
+    width: fit-content;
+    display: flex;
+    justify-content: center;
+  }
+
+  .txt {
+    max-width: 70vw;
+    max-height: 70vh;
+
+    .code {
+      height: 100%;
+      padding: 10px;
+      overflow-y: auto;
+      background-color: #fff;
+      border: 1px solid rgba(0, 0, 0, 0.15);
+    }
+  }
+
+  .ppt {
+    text-align: center;
+    align-items: center;
+
+    img {
+      height: fit-content;
+    }
+  }
+
+  .error {
+    text-align: center;
+    color: #fff;
+
+    .error-title {
+      font-size: 24px;
+      font-weight: bold;
+      margin-bottom: 16px;
+    }
+
+    .error-tip {
+      font-size: 16px;
+    }
+  }
+
+  .iframe {
+    height: 80vh;
+    width: 50vw;
+    border: medium none;
+    background-color: white;
+  }
+
+  .preview_content {
+    width: 100%;
+    height: 100%;
+    padding: 30px 0;
+    display: flex;
+    justify-content: center;
+  }
+
+  .pdf-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 30px 0;
+    overflow: hidden;
+
+    .pdf-loading {
+      width: 50px;
+      height: 50px;
+    }
+
+    .react-pdf__Document {
+      max-width: 100%;
+      height: 100%;
+      margin: 0 auto;
+      overflow: auto;
+    }
+
+    .react-pdf__Page__textContent {
+      display: none;
+    }
+
+    .react-pdf__Page__annotations {
+      display: none;
+    }
+
+    .pdf-content {
+      display: flex;
+      flex: 1;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+    }
+  }
+
+  .@{prefixCls}-group {
+    display: flex;
+    align-items: center;
+    padding: 13px 0;
+
+    &:empty {
+      display: none;
+    }
+
+    &:last-child {
+      padding-right: 32px;
+    }
+
+    &:first-child {
+      padding-left: 32px;
+    }
+
+    &:not(:last-child) {
+      &::after {
+        content: '';
+        display: flex;
+        width: 1px;
+        height: 14px;
+        margin: 0 16px;
+        background-color: #fff;
+      }
+    }
+  }
+}
+
+.@{prefixCls} {
+  &-zip-select {
+    color: white;
+    width: 256px;
+    overflow: hidden;
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+  }
+
+  &-zip-select-label {
+    flex: 1;
+    overflow: hidden;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  &-dropdown {
+    margin-bottom: 12px;
+    border-radius: @border-radius-base;
+    max-width: 65vw;
+    overflow: auto;
+
+    .@{ant-prefix}-cascader-menu-item-content {
+      display: inline-block;
+      flex: 1;
+      overflow: hidden;
+      max-width: 128px;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+    }
+
+    .@{ant-prefix}-cascader-menu {
+      padding: 4px;
+
+      &-item {
+        border-radius: @border-radius-base;
+      }
+    }
+
+    .@{ant-prefix}-cascader-menus
+      .@{ant-prefix}-cascader-menu-item-active:not(
+        .@{ant-prefix}-cascader-menus .@{ant-prefix}-cascader-menu-item-disabled
+      ) {
+      background-color: fade(@primary-color, 8%);
+    }
+  }
+
+  &-error-tips {
+    font-size: @font-size-md;
+  }
+}