resolver-egretimp-plus 0.1.113 → 0.1.115

package/src-bak/theme/element/components/tabs.scss

@@ -0,0 +1,128 @@
+
+@import "./common.scss";
+
+.resolver-tabs {
+  // 这个是渲染器里面tabs
+  // display: block;
+}
+.hidden-bar {
+  &::after {
+    display: none;
+  }
+}
+.hidden-head-underline {
+  & > .el-tabs__header {
+    & > .el-tabs__nav-wrap {
+      &::after {
+        display: none;
+      }
+    }
+  }
+}
+
+.el-tabs {
+  --el-text-color-primary: #1F2329;
+  // display: block;
+  border-radius: 4px;
+  overflow: hidden;
+  &.el-tabs--border-card>.el-tabs__content {
+    padding: var(--prmary-marign-second) var(--prmary-marign) var(--prmary-marign) var(--prmary-marign);
+  }
+}
+.el-tabs__active-bar {
+  bottom: 1px;
+  height: 3px;
+  border-radius: 2px;
+}
+.el-tabs__item {
+  padding: 0 16px;
+  min-height: var(--el-tabs-header-height);
+  height: unset;
+  font-weight: 400;
+  &.is-active {
+    font-weight: 500;
+  }
+}
+.el-tabs__header {
+  margin: 0 0 16px;
+}
+.tabs-level-1 {
+  --el-tabs-header-height: 49px;
+  &.full-border {
+    & > .el-tabs__header {
+      .el-tabs__item.is-active {
+        border-right: 1px solid var(--el-border-color-light)
+      }
+    }
+  }
+  & > .el-tabs__header {
+    .el-tabs__item {
+      position: relative;
+      min-width: 180px;
+      max-width: calc(50% + 1px);
+      &::after {
+        content: "";
+        position: absolute;
+        display: block;
+        right: -1px;
+        top: 50%;
+        transform: translateY(-50%);
+        height: 50%;
+        width: 1px;
+        background-color: #d0d3d6;
+      }
+      &:last-child {
+        border-right: none;
+        &::after {
+          display: none;
+        }
+      }
+      &:only-child {
+        border-right: 1px solid var(--el-border-color);
+      }
+    }
+  }
+}
+
+.tabs-level-2 {
+  & > .el-tabs__header {
+    .el-tabs__nav-wrap::after {
+      height: 1px;
+    }
+  }
+}
+.tabs-level-3 {
+  --el-tabs-header-height: 32px;
+  &.el-tabs--card > .el-tabs__header {
+    border-bottom: none;
+    .el-tabs__item {
+      border-bottom: none;
+      border-left: none;
+      border-radius: 4px;
+      &.is-active {
+        background-color: #eaf0fe;
+      }
+    }
+    .el-tabs__nav {
+      border: none;
+    }
+  }
+}
+.tabpane-auto-header {
+  & > .el-tabs__header {
+    --el-tabs-header-height: auto;
+  }
+}
+.CustomComponentTabs {
+  .el-tabs__content {
+    margin-right: -16px;
+    .el-tab-pane {
+      @include nestMargin
+    }
+  }
+}
+.tabs__item-wrap {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}

package/src-bak/theme/element/components/tag.scss

@@ -0,0 +1,6 @@
+.el-tag {
+  --el-tag-font-size: 14px;
+  &.el-tag--info {
+    --el-tag-text-color: #1f2329;
+  }
+}

package/{src/components/styles → src-bak/theme/element/components}/text.scss

@@ -1,3 +1,6 @@
+.el-text {
+  line-height: 1em;
+}
 .resolver-custom-cust-input-wrap {
   display: flex;
   width: 100%;
@@ -14,7 +17,4 @@
 }
 .resolver-custom-is-disabled {
   background: var(--el-disabled-bg-color);
-}
-.cursor {
-  cursor: pointer;
 }

package/src-bak/theme/element/components/textarea.scss

@@ -0,0 +1,3 @@
+.el-textarea {
+  --el-input-text-color: #1f2329;
+}

package/src-bak/theme/element/index.scss

@@ -0,0 +1,55 @@
+@import './components/index.scss';
+* {
+  font-family: PingFang SC,sans-serif;
+  font-weight: inherit;
+}
+.custom-form-item.hidden-label {
+  & > {
+    .el-form-item__label, .simple-form-item-label {
+      display: none;
+    }
+  }
+  & > .el-form-item__label-wrap {
+    display: none;
+  }
+}
+.content-right {
+  .el-form-item__content, .simple-form-item-content {
+    text-align: right;
+    justify-content: flex-end;
+  }
+}
+
+.is-disabled {
+  & > [class*=__suffix] {
+    display: none;
+  }
+  & > [class*=__wrapper] {
+    & > [class*=__suffix] {
+      display: none;
+    }
+  }
+  &.el-date-editor {
+    & > .el-input__wrapper {
+      & > .el-input__prefix {
+        display: none;
+      }
+    }
+  }
+}
+
+
+.resolver-calc-contrainer {
+  width: 100%;
+  .resolver-calc-span {
+    white-space: nowrap;
+    position: absolute;
+    visibility: hidden;
+    padding: 0 11px;
+    box-sizing: border-box;
+  }
+  .resolver-calc-wrap{
+    line-height: 0;
+    width: 100%;
+  }
+}

package/src-bak/utils/cipher.js

@@ -0,0 +1,141 @@
+import { decrypt as aesDecrypt, encrypt as aesEncrypt } from 'crypto-js/aes';
+import UTF8 from 'crypto-js/enc-utf8';
+import pkcs7 from 'crypto-js/pad-pkcs7';
+import CTR from 'crypto-js/mode-ctr';
+import Base64 from 'crypto-js/enc-base64';
+import MD5 from 'crypto-js/md5';
+import SHA256 from 'crypto-js/sha256';
+import SHA512 from 'crypto-js/sha512';
+
+class AesEncryption {
+  key;
+  iv;
+  constructor({ key, iv }) {
+    this.key = UTF8.parse(key);
+    this.iv = UTF8.parse(iv);
+  }
+
+  get getOptions() {
+    return {
+      mode: CTR,
+      padding: pkcs7,
+      iv: this.iv,
+    };
+  }
+
+  encrypt(plainText) {
+    return aesEncrypt(plainText, this.key, this.getOptions).toString();
+  }
+
+  decrypt(cipherText) {
+    return aesDecrypt(cipherText, this.key, this.getOptions).toString(UTF8);
+  }
+}
+
+// Define a singleton class for Base64 encryption
+class Base64Encryption{
+  instance;
+
+  constructor() {}
+
+  // Get the singleton instance
+  // 获取单例实例
+  getInstance() {
+    if (!Base64Encryption.instance) {
+      Base64Encryption.instance = new Base64Encryption();
+    }
+    return Base64Encryption.instance;
+  }
+
+  encrypt(plainText) {
+    return UTF8.parse(plainText).toString(Base64);
+  }
+
+  decrypt(cipherText) {
+    return Base64.parse(cipherText).toString(UTF8);
+  }
+}
+
+// Define a singleton class for MD5 Hashing
+class MD5Hashing {
+  instance;
+
+  constructor() {}
+
+  // Get the singleton instance
+  // 获取单例实例
+  static getInstance() {
+    if (!MD5Hashing.instance) {
+      MD5Hashing.instance = new MD5Hashing();
+    }
+    return MD5Hashing.instance;
+  }
+
+  hash(plainText) {
+    return MD5(plainText).toString();
+  }
+}
+
+// Define a singleton class for SHA256 Hashing
+class SHA256Hashing {
+  static instance;
+
+  constructor() {}
+
+  // Get the singleton instance
+  // 获取单例实例
+  static getInstance() {
+    if (!SHA256Hashing.instance) {
+      SHA256Hashing.instance = new SHA256Hashing();
+    }
+    return SHA256Hashing.instance;
+  }
+
+  hash(plainText) {
+    return SHA256(plainText).toString();
+  }
+}
+
+// Define a singleton class for SHA512 Hashing
+class SHA512Hashing {
+  static instance;
+
+  constructor() {}
+
+  // Get the singleton instance
+  // 获取单例实例
+  static getInstance() {
+    if (!SHA512Hashing.instance) {
+      SHA512Hashing.instance = new SHA512Hashing();
+    }
+    return SHA512Hashing.instance;
+  }
+
+  hash(plainText) {
+    return SHA512(plainText).toString();
+  }
+}
+
+export class EncryptionFactory {
+  static createAesEncryption(params) {
+    return new AesEncryption(params);
+  }
+
+  static createBase64Encryption() {
+    return Base64Encryption.getInstance();
+  }
+}
+
+export class HashingFactory {
+  static createMD5Hashing() {
+    return MD5Hashing.getInstance();
+  }
+
+  static createSHA256Hashing() {
+    return SHA256Hashing.getInstance();
+  }
+
+  static createSHA512Hashing() {
+    return SHA512Hashing.getInstance();
+  }
+}