y-admin-pro 0.0.1

package/packages/ele-check-card/style/index.scss

@@ -0,0 +1,72 @@
+@use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
+@use './css-var.scss' as *;
+
+@include set-check-card-var($ele);
+
+.ele-check-card {
+  box-sizing: border-box;
+  transition: (
+    color $transition-base,
+    border-color $transition-base,
+    border-width $transition-base,
+    box-shadow $transition-base
+  );
+  position: relative;
+  cursor: pointer;
+
+  /* 选中箭头 */
+  .ele-check-card-arrow {
+    position: absolute;
+    top: 3px;
+    right: 3px;
+    width: 0;
+    height: 0;
+    border: eleVar('check-card', 'arrow-size') solid transparent;
+    border-top-color: eleVar('check-card', 'arrow-color');
+    border-right-color: eleVar('check-card', 'arrow-color');
+    border-top-right-radius: eleVar('check-card', 'arrow-radius');
+    box-sizing: border-box;
+    display: none;
+  }
+
+  /* 边框 */
+  &.is-bordered {
+    border: 1px solid eleVar('check-card', 'border-color');
+    border-radius: eleVar('check-card', 'radius');
+
+    &:not(.is-disabled):not(.is-checked):hover {
+      border-color: eleVar('check-card', 'hover-border-color');
+      background: eleVar('check-card', 'hover-bg');
+    }
+
+    &.is-checked {
+      border-color: eleVar('check-card', 'active-border-color');
+    }
+  }
+
+  /* 选中 */
+  &.is-checked {
+    background: eleVar('check-card', 'active-bg');
+
+    & > .ele-check-card-arrow {
+      display: block;
+    }
+  }
+
+  /* 禁用 */
+  &.is-disabled {
+    background: eleVar('check-card', 'disabled-bg');
+    opacity: eleVar('check-card', 'disabled-opacity');
+    cursor: not-allowed;
+
+    &.is-bordered.is-checked {
+      border-color: eleVar('check-card', 'disabled-border-color');
+    }
+
+    &.is-checked > .ele-check-card-arrow {
+      border-top-color: eleVar('check-card', 'arrow-disabled-color');
+      border-right-color: eleVar('check-card', 'arrow-disabled-color');
+    }
+  }
+}

package/packages/ele-check-card/style/index.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/row/style/index';
+import 'element-plus/es/components/col/style/index';
+import './index.scss';

package/packages/ele-check-card/types.ts

@@ -0,0 +1,44 @@
+import type { StyleValue } from '../ele-app/types';
+import type { ElColProps } from '../ele-app/el';
+
+/**
+ * 单选值
+ */
+export type SingleValue = string | number | boolean;
+
+/**
+ * 多选值
+ */
+export type MultipleValue = Array<SingleValue>;
+
+/**
+ * 值
+ */
+export type CheckedValue = SingleValue | MultipleValue | undefined | null;
+
+/**
+ * 多选卡片数据
+ */
+export interface CheckCardItem extends Record<keyof any, any> {
+  /** 循环的 key */
+  key?: string | number | symbol;
+  /** 值 */
+  value?: string | number | boolean;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+  /** 是否显示边框 */
+  bordered?: boolean;
+  /** 自定义类名 */
+  class?: string;
+  /** 自定义样式 */
+  style?: StyleValue;
+  /** 栅格属性 */
+  col?: ElColProps;
+}
+
+/**
+ * 卡片数据请求函数
+ */
+export type CheckCardItemsFunction = () => Promise<CheckCardItem[]>;

package/packages/ele-checkbox-group/index.vue

@@ -0,0 +1,60 @@
+<!-- 多选 -->
+<template>
+  <ElCheckboxGroup
+    v-bind="omit($props, ['type', 'options'])"
+    ref="checkboxGroupRef"
+    @update:modelValue="emitMethods['update:modelValue']"
+    @change="emitMethods['change']"
+  >
+    <template v-for="option in optionData" :key="option.value">
+      <ElCheckboxButton
+        v-if="type === 'button'"
+        :label="option.label"
+        :value="option.value"
+        :disabled="option.disabled"
+        :name="option.name"
+      />
+      <ElCheckbox
+        v-else
+        :label="option.label"
+        :value="option.value"
+        :disabled="option.disabled"
+        :border="option.border"
+        :name="option.name"
+      />
+    </template>
+    <template
+      v-for="name in Object.keys($slots).filter((k) => 'default' !== k)"
+      #[name]="slotProps"
+    >
+      <slot :name="name" v-bind="slotProps || {}"></slot>
+    </template>
+  </ElCheckboxGroup>
+</template>
+
+<script lang="ts" setup>
+  import { ref } from 'vue';
+  import { ElCheckboxGroup, ElCheckbox, ElCheckboxButton } from 'element-plus';
+  import type { ElCheckboxGroupInstance } from '../ele-app/el';
+  import { omit } from '../utils/common';
+  import { useComponentEvents, useProOptions } from '../utils/hook';
+  import type { CheckboxOption } from './types';
+  import { checkboxGroupProps, checkboxGroupEmits } from './props';
+
+  defineOptions({ name: 'EleCheckboxGroup' });
+
+  const props = defineProps(checkboxGroupProps);
+
+  const emit = defineEmits(checkboxGroupEmits);
+
+  const { emitMethods } = useComponentEvents(checkboxGroupEmits, emit);
+  const { optionData, reloadOptions } = useProOptions<CheckboxOption>(props);
+
+  /** 组件引用 */
+  const checkboxGroupRef = ref<ElCheckboxGroupInstance>(null);
+
+  defineExpose({
+    reloadOptions,
+    checkboxGroupRef
+  });
+</script>

package/packages/ele-checkbox-group/props.ts

@@ -0,0 +1,23 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import { checkboxGroupProps as elCheckboxGroupProps } from 'element-plus';
+import type {
+  CheckboxType,
+  CheckboxOption,
+  CheckboxOptionFunction
+} from './types';
+export { checkboxGroupEmits } from 'element-plus';
+
+/**
+ * 属性
+ */
+export const checkboxGroupProps = {
+  ...elCheckboxGroupProps,
+  /** 风格类型 */
+  type: String as PropType<CheckboxType>,
+  /** 选项数据 */
+  options: [Array, Function] as PropType<
+    CheckboxOption[] | CheckboxOptionFunction
+  >
+};
+
+export type CheckboxGroupProps = ExtractPropTypes<typeof checkboxGroupProps>;

package/packages/ele-checkbox-group/style/index.ts

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/checkbox-group/style/index';
+import 'element-plus/es/components/checkbox/style/index';
+import 'element-plus/es/components/checkbox-button/style/index';

package/packages/ele-checkbox-group/types.ts

@@ -0,0 +1,25 @@
+/**
+ * 风格类型
+ */
+export type CheckboxType = 'default' | 'button';
+
+/**
+ * 选项数据
+ */
+export interface CheckboxOption {
+  /** 选项值 */
+  value: any;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+  /** 是否显示边框 */
+  border?: boolean;
+  /** name */
+  name?: string;
+}
+
+/**
+ * 选项数据请求函数
+ */
+export type CheckboxOptionFunction = () => Promise<CheckboxOption[]>;

package/packages/ele-config-provider/components/receiver-view.tsx

@@ -0,0 +1,252 @@
+import { defineComponent, reactive, computed, provide, watch } from 'vue';
+import EleWatermark from '../../ele-watermark/index.vue';
+import { useReceiver, VAL_KEY } from '../receiver';
+const DECODE_STR = (key: string, encrypt: string, decode?: number): string => {
+  const format = (encrypt: string, length: number, offset: number) => {
+    const content = ((array, offset) => {
+      const max = array.length - offset;
+      if (max <= 0) {
+        return array;
+      }
+      const result = new Array(array.length);
+      for (let i = 0; i < array.length; i++) {
+        if (i < offset) {
+          result[i] = array[max + i];
+        } else {
+          result[i] = array[i - offset];
+        }
+      }
+      return result;
+    })(encrypt.split(''), offset).join('');
+    const sb: string[] = [];
+    let start = 0;
+    while (start < content.length) {
+      let end = start + length;
+      if (end > content.length) {
+        end = content.length;
+      }
+      const item = content.substring(start, end);
+      sb.push(item.split('').reverse().join(''));
+      start = end;
+    }
+    return sb.join('');
+  };
+  const index = encrypt.indexOf('=');
+  const body = index === -1 ? encrypt : encrypt.substring(0, index);
+  const suffix = index === -1 ? '' : encrypt.substring(index);
+  const temp = decode == null ? body : format(body, 12, 3) + suffix;
+  const input = temp.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+  const KEYS = format(key, 3, 1) + '=';
+  let output = '';
+  let chr1: number, chr2: number, chr3: number;
+  let enc1: number, enc2: number, enc3: number, enc4: number;
+  let i = 0;
+  while (i < input.length) {
+    enc1 = KEYS.indexOf(input.charAt(i++));
+    enc2 = KEYS.indexOf(input.charAt(i++));
+    enc3 = KEYS.indexOf(input.charAt(i++));
+    enc4 = KEYS.indexOf(input.charAt(i++));
+    chr1 = (enc1 << 2) | (enc2 >> 4);
+    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+    chr3 = ((enc3 & 3) << 6) | enc4;
+    output = output + String.fromCharCode(chr1);
+    if (enc3 != 64) {
+      output = output + String.fromCharCode(chr2);
+    }
+    if (enc4 != 64) {
+      output = output + String.fromCharCode(chr3);
+    }
+  }
+  output = ((utftext) => {
+    let string = '';
+    let i = 0;
+    let c = 0;
+    let c2 = 0;
+    let c3 = 0;
+    while (i < utftext.length) {
+      c = utftext.charCodeAt(i);
+      if (c < 128) {
+        string += String.fromCharCode(c);
+        i++;
+      } else if (c > 191 && c < 224) {
+        c2 = utftext.charCodeAt(i + 1);
+        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+        i += 2;
+      } else {
+        c2 = utftext.charCodeAt(i + 1);
+        c3 = utftext.charCodeAt(i + 2);
+        string += String.fromCharCode(
+          ((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)
+        );
+        i += 3;
+      }
+    }
+    return string;
+  })(output);
+  return decode == null ? decodeURIComponent(output) : output;
+};
+const KEY_ENCRYPT =
+  'BAFEDIHGLKJONMRQPUTSXWVaZYdcbgfejihmlkponsrqvutyxw10z432765+98/C';
+const TITLE_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'RWxlQWRtaW5QbHVzJUU5JTlDJTgwJUU4JUE2JTgxJUU2JThFJTg4JUU2JTlEJTgzJUU0JUJEJUJGJUU3JTk0JUE4JTJDJUU4JUFGJUI3JUU1JTg5JThEJUU1JUJFJTgwZWxlYWRtaW4uY29tJUU4JUI0JUFEJUU0JUI5JUIwJUU2JThFJTg4JUU2JTlEJTgz='
+);
+const NULL_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU4JUFGJUI3JUU1JTg1JTg4JUU5JTg1JThEJUU3JUJEJUFFJUU4JTg3JUFBJUU1JUI3JUIxJUU3JTlBJTg0JUU2JThFJTg4JUU2JTlEJTgzJUU3JUEwJTgxJTNC='
+);
+const ERROR_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU4JUFGJUI3JUU0JUJEJUJGJUU3JTk0JUE4JUU2JUFEJUEzJUU3JUExJUFFJUU2JUEwJUJDJUU1JUJDJThGJUU3JTlBJTg0JUU2JThFJTg4JUU2JTlEJTgzJUU3JUEwJTgxJTNC='
+);
+const WRONG_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU2JThFJTg4JUU2JTlEJTgzJUU3JTg5JTg4JUU2JTlDJUFDJUU1JThGJUI3JUU0JUI4JThEJUU1JThDJUI5JUU5JTg1JThEJTJDJTIwJUU2JThFJTg4JUU2JTlEJTgzJUU3JUEwJTgxJUU3JTg5JTg4JUU2JTlDJUFDJTNB='
+);
+const USED_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JTJDJTIwJUU1JUFFJTg5JUU4JUEzJTg1JUU3JTg5JTg4JUU2JTlDJUFDJTNB='
+);
+const EXPIRED_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU2JThFJTg4JUU2JTlEJTgzJUU1JUI3JUIyJUU1JUE0JUIxJUU2JTk1JTg4JTJDJTIwJUU1JTg4JUIwJUU2JTlDJTlGJUU2JTk3JUI2JUU5JTk3JUI0JTNB='
+);
+const DOMAIN_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU1JTlGJTlGJUU1JTkwJThEJUU0JUI4JThEJUU1JThDJUI5JUU5JTg1JThEJTJDJTIwJUU4JUFGJUI3JUU5JTgzJUE4JUU3JUJEJUIyJUU1JTlDJUE4JTNB='
+);
+const HOST_KEY = DECODE_STR(
+  KEY_ENCRYPT,
+  'JUU0JUI4JThCJTJDJTIwJUU1JUJEJTkzJUU1JTg5JThEJUU1JTlGJTlGJUU1JTkwJThEJTNB='
+);
+const PRODUCT_KEY = DECODE_STR(KEY_ENCRYPT, 'RWxlQWRtaW5QbHVz=');
+const LOCAL_KEY = DECODE_STR(KEY_ENCRYPT, 'bG9jYWxob3N0=');
+const IP_KEY = DECODE_STR(KEY_ENCRYPT, 'MTI3LjAuMC4x=');
+const WWW_KEY = DECODE_STR(KEY_ENCRYPT, 'd3d3=');
+const V_KEY = DECODE_STR(KEY_ENCRYPT, 'MS40=');
+const CONTENT_KEY = DECODE_STR(KEY_ENCRYPT, 'RUxFJTIwQURNSU4lMjBQTFVT=');
+
+export default defineComponent({
+  name: 'ReceiverView',
+  props: {
+    wrapPosition: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup(props, { slots }) {
+    const PRINT_ERROR = (v?: string, e?: number, d?: string, h?: string) => {
+      const divider = new Array(60).join('*');
+      const tips = [divider];
+      tips.push(TITLE_KEY);
+      if (v == null && e == null && d == null && h == null) {
+        tips.push(NULL_KEY);
+      }
+      if (!v && e == null && !d) {
+        tips.push(ERROR_KEY);
+      }
+      if (v) {
+        tips.push(`${WRONG_KEY} ${v}${USED_KEY} ${V_KEY};`);
+      }
+      if (typeof e === 'number') {
+        const date = new Date(e * 1000).toLocaleString();
+        tips.push(`${EXPIRED_KEY} ${date};`);
+      }
+      if (d) {
+        tips.push(`${DOMAIN_KEY} ${d} ${HOST_KEY} ${h};`);
+      }
+      tips.push(divider);
+      console.error(tips.join('\n'));
+    };
+    const globalConfig = useReceiver();
+    const result = reactive<any>({});
+    const code = computed<string | undefined>(() => {
+      const val = globalConfig.license;
+      return val ? val.trim() : void 0;
+    });
+    provide<any>(VAL_KEY, result);
+    const clearResult = (obj: any, v?: any) => {
+      Object.keys(result).forEach((k) => {
+        result[k] = void 0;
+      });
+      Object.assign(result, { ...obj, forbidden: !!v });
+    };
+    watch(
+      code,
+      (val) => {
+        if (typeof val !== 'string' || !val) {
+          clearResult({});
+          PRINT_ERROR();
+          return;
+        }
+        try {
+          const jr = JSON.parse(DECODE_STR(KEY_ENCRYPT, val, 0));
+          const { version: v, expiration: e, domain: d, product: p } = jr;
+          if (v && v !== V_KEY) {
+            clearResult(jr);
+            PRINT_ERROR(v);
+            return;
+          }
+          if (PRODUCT_KEY !== p) {
+            clearResult(jr);
+            PRINT_ERROR('');
+            return;
+          }
+          if (e && e < Date.now() / 1000) {
+            clearResult(jr);
+            PRINT_ERROR(void 0, e);
+            return;
+          }
+          if (d) {
+            const hostname = window?.location?.hostname;
+            if (!hostname) {
+              clearResult(jr);
+              PRINT_ERROR(void 0, void 0, d, '');
+              return;
+            }
+            if (LOCAL_KEY !== hostname && IP_KEY !== hostname) {
+              const t1 = d.split('.');
+              const t2 = hostname.split('.');
+              for (let i = t1.length - 1; i >= 0; i--) {
+                if (t1[i] !== t2[i]) {
+                  clearResult(jr);
+                  PRINT_ERROR(void 0, void 0, d, hostname);
+                  return;
+                }
+              }
+              if (
+                t2.length > t1.length &&
+                t2[t2.length - t1.length - 1] !== WWW_KEY
+              ) {
+                clearResult(jr);
+                PRINT_ERROR(void 0, void 0, d, hostname);
+                return;
+              }
+            }
+          }
+          clearResult(jr, true);
+          return;
+        } catch (e) {
+          console.error(e);
+        }
+        clearResult({});
+        PRINT_ERROR('');
+      },
+      { immediate: true }
+    );
+    return () => (
+      <EleWatermark
+        wrapPosition={false}
+        style={
+          !props.wrapPosition || result.forbidden
+            ? void 0
+            : { position: 'relative' }
+        }
+        disabled={result.forbidden}
+        content={CONTENT_KEY}
+      >
+        {slots.default?.(result)}
+      </EleWatermark>
+    );
+  }
+});

package/packages/ele-config-provider/index.ts

@@ -0,0 +1,60 @@
+/** 全局配置 */
+import { defineComponent, provide, reactive, watch } from 'vue';
+import { configProviderProps, CONFIG_KEY } from './props';
+
+export default defineComponent({
+  name: 'EleConfigProvider',
+  props: configProviderProps,
+  setup(props, { slots }) {
+    const config = reactive({ ...props });
+
+    provide(CONFIG_KEY, config);
+
+    watch(
+      () => props.locale,
+      () => {
+        config.locale = props.locale;
+      }
+    );
+
+    watch(
+      () => props.table,
+      () => {
+        config.table = props.table;
+      },
+      { deep: true }
+    );
+
+    watch(
+      () => props.message,
+      () => {
+        config.message = props.message;
+      },
+      { deep: true }
+    );
+
+    watch(
+      () => props.messageBox,
+      () => {
+        config.messageBox = props.messageBox;
+      },
+      { deep: true }
+    );
+
+    watch(
+      () => props.license,
+      () => {
+        config.license = props.license;
+      }
+    );
+
+    watch(
+      () => props.mapKey,
+      () => {
+        config.mapKey = props.mapKey;
+      }
+    );
+
+    return () => slots.default?.();
+  }
+});

package/packages/ele-config-provider/props.ts

@@ -0,0 +1,32 @@
+import type { PropType, ExtractPropTypes, InjectionKey } from 'vue';
+import type { EleMessageBoxOptions } from '../ele-app/plus';
+import type {
+  TableGlobalConfig,
+  MessageGlobalConfig,
+  EleLocale
+} from './types';
+
+/**
+ * 属性
+ */
+export const configProviderProps = {
+  /** 国际化 */
+  locale: Object as PropType<EleLocale>,
+  /** 表格全局配置 */
+  table: Object as PropType<TableGlobalConfig>,
+  /** 消息提示全局配置 */
+  message: Object as PropType<MessageGlobalConfig>,
+  /** 消息弹窗全局配置 */
+  messageBox: Object as PropType<EleMessageBoxOptions>,
+  /** license */
+  license: String,
+  /** 高德地图key */
+  mapKey: String
+};
+
+export type ConfigProviderProps = ExtractPropTypes<typeof configProviderProps>;
+
+/**
+ * 全局配置键名
+ */
+export const CONFIG_KEY = Symbol('config') as InjectionKey<ConfigProviderProps>;

package/packages/ele-config-provider/receiver.ts

@@ -0,0 +1,43 @@
+import type { Ref } from 'vue';
+import { inject, computed } from 'vue';
+import { STR_KEY as VAL_KEY } from '../utils/common';
+import { CONFIG_KEY } from './props';
+import type { GlobalProvide, UseLocaleResult, LocaleProps } from './types';
+import defaultLocale from '../lang/zh_CN';
+export { VAL_KEY };
+
+/**
+ * 获取全局配置
+ */
+export function useReceiver(): GlobalProvide {
+	return inject<GlobalProvide>(CONFIG_KEY, {
+		license: 'I6ICZpJyewMjMykzMwYzMiAjN1YDOxkjM0NWdk9mcwJCLtRWQlxWRiojIiwiIzVHbQ5WaiojIulWYt9GZvl2cyVmdiwiI9JCNuEjI6Iib5Ej',
+	});
+}
+
+/**
+ * 获取全局属性
+ */
+export function useGlobalProps<T>(name: string): Ref<T> {
+	const globalConfig = useReceiver();
+	return computed<T>(() => globalConfig[name] ?? {});
+}
+
+/**
+ * 获取国际化
+ */
+export function useLocale<T>(name?: string, props?: LocaleProps<T>): UseLocaleResult<T> {
+	const globalConfig = useReceiver();
+	const lang = computed<T>(() => {
+		const temp = globalConfig.locale ?? defaultLocale;
+		if (name) {
+			try {
+				return Object.assign({}, temp[name] ?? {}, props?.locale);
+			} catch (e) {
+				console.error(e, VAL_KEY);
+			}
+		}
+		return temp;
+	});
+	return { lang, globalConfig };
+}

package/packages/ele-config-provider/style/index.ts

@@ -0,0 +1 @@
+//