@tuya-sat/sdf-main-sdk 0.0.1-beta.1

package/src/utils/gt.js

@@ -0,0 +1,293 @@
+/* eslint-disable */
+/* initGeetest 1.0.0
+ * 用于加载id对应的验证码库，并支持宕机模式
+ * 暴露 initGeetest 进行验证码的初始化
+ * 一般不需要用户进行修改
+ */
+(function (global, factory) {
+  'use strict';
+  if (typeof module === 'object' && typeof module.exports === 'object') {
+    // CommonJS
+    module.exports = global.document
+      ? factory(global, true)
+      : function (w) {
+          if (!w.document) {
+            throw new Error('Geetest requires a window with a document');
+          }
+          return factory(w);
+        };
+  } else {
+    factory(global);
+  }
+})(typeof window !== 'undefined' ? window : this, function (window, noGlobal) {
+  'use strict';
+  if (typeof window === 'undefined') {
+    throw new Error('Geetest requires browser environment');
+  }
+  var document = window.document;
+  var Math = window.Math;
+  var head = document.getElementsByTagName('head')[0];
+
+  function _Object(obj) {
+    this._obj = obj;
+  }
+
+  _Object.prototype = {
+    _each: function (process) {
+      var _obj = this._obj;
+      for (var k in _obj) {
+        if (_obj.hasOwnProperty(k)) {
+          process(k, _obj[k]);
+        }
+      }
+      return this;
+    },
+  };
+  function Config(config) {
+    var self = this;
+    new _Object(config)._each(function (key, value) {
+      self[key] = value;
+    });
+  }
+
+  Config.prototype = {
+    api_server: 'api.geetest.com',
+    protocol: 'http://',
+    type_path: '/gettype.php',
+    fallback_config: {
+      slide: {
+        static_servers: ['static.geetest.com', 'dn-staticdown.qbox.me'],
+        type: 'slide',
+        slide: '/static/js/geetest.0.0.0.js',
+      },
+      fullpage: {
+        static_servers: ['static.geetest.com', 'dn-staticdown.qbox.me'],
+        type: 'fullpage',
+        fullpage: '/static/js/fullpage.0.0.0.js',
+      },
+    },
+    _get_fallback_config: function () {
+      var self = this;
+      if (isString(self.type)) {
+        return self.fallback_config[self.type];
+      } else if (self.new_captcha) {
+        return self.fallback_config.fullpage;
+      } else {
+        return self.fallback_config.slide;
+      }
+    },
+    _extend: function (obj) {
+      var self = this;
+      new _Object(obj)._each(function (key, value) {
+        self[key] = value;
+      });
+    },
+  };
+  var isNumber = function (value) {
+    return typeof value === 'number';
+  };
+  var isString = function (value) {
+    return typeof value === 'string';
+  };
+  var isBoolean = function (value) {
+    return typeof value === 'boolean';
+  };
+  var isObject = function (value) {
+    return typeof value === 'object' && value !== null;
+  };
+  var isFunction = function (value) {
+    return typeof value === 'function';
+  };
+  var callbacks = {};
+  var status = {};
+  var random = function () {
+    return parseInt(Math.random() * 10000) + new Date().valueOf();
+  };
+  var loadScript = function (url, cb) {
+    var script = document.createElement('script');
+    script.charset = 'UTF-8';
+    script.async = true;
+    script.onerror = function () {
+      cb(true);
+    };
+    var loaded = false;
+    script.onload = script.onreadystatechange = function () {
+      if (
+        !loaded &&
+        (!script.readyState ||
+          'loaded' === script.readyState ||
+          'complete' === script.readyState)
+      ) {
+        loaded = true;
+        setTimeout(function () {
+          cb(false);
+        }, 0);
+      }
+    };
+    script.src = url;
+    head.appendChild(script);
+  };
+  var normalizeDomain = function (domain) {
+    return domain.replace(/^https?:\/\/|\/$/g, '');
+  };
+  var normalizePath = function (path) {
+    path = path.replace(/\/+/g, '/');
+    if (path.indexOf('/') !== 0) {
+      path = '/' + path;
+    }
+    return path;
+  };
+  var normalizeQuery = function (query) {
+    if (!query) {
+      return '';
+    }
+    var q = '?';
+    new _Object(query)._each(function (key, value) {
+      if (isString(value) || isNumber(value) || isBoolean(value)) {
+        q = q + encodeURIComponent(key) + '=' + encodeURIComponent(value) + '&';
+      }
+    });
+    if (q === '?') {
+      q = '';
+    }
+    return q.replace(/&$/, '');
+  };
+  var makeURL = function (protocol, domain, path, query) {
+    domain = normalizeDomain(domain);
+
+    var url = normalizePath(path) + normalizeQuery(query);
+    if (domain) {
+      url = protocol + domain + url;
+    }
+
+    return url;
+  };
+  var load = function (protocol, domains, path, query, cb) {
+    var tryRequest = function (at) {
+      var url = makeURL(protocol, domains[at], path, query);
+      loadScript(url, function (err) {
+        if (err) {
+          if (at >= domains.length - 1) {
+            cb(true);
+          } else {
+            tryRequest(at + 1);
+          }
+        } else {
+          cb(false);
+        }
+      });
+    };
+    tryRequest(0);
+  };
+  var jsonp = function (domains, path, config, callback) {
+    if (isObject(config.getLib)) {
+      config._extend(config.getLib);
+      callback(config);
+      return;
+    }
+    if (config.offline) {
+      callback(config._get_fallback_config());
+      return;
+    }
+    var cb = 'geetest_' + random();
+    window[cb] = function (data) {
+      if (data.status === 'success') {
+        callback(data.data);
+      } else if (!data.status) {
+        callback(data);
+      } else {
+        callback(config._get_fallback_config());
+      }
+      window[cb] = undefined;
+      try {
+        delete window[cb];
+      } catch (e) {}
+    };
+    load(
+      config.protocol,
+      domains,
+      path,
+      {
+        gt: config.gt,
+        callback: cb,
+      },
+      function (err) {
+        if (err) {
+          callback(config._get_fallback_config());
+        }
+      },
+    );
+  };
+  var throwError = function (errorType, config) {
+    var errors = {
+      networkError: '网络错误',
+    };
+    if (typeof config.onError === 'function') {
+      config.onError(errors[errorType]);
+    } else {
+      throw new Error(errors[errorType]);
+    }
+  };
+  var detect = function () {
+    return !!window.Geetest;
+  };
+  if (detect()) {
+    status.slide = 'loaded';
+  }
+  var initGeetest = function (userConfig, callback) {
+    var config = new Config(userConfig);
+    if (userConfig.https) {
+      config.protocol = 'https://';
+    } else if (!userConfig.protocol) {
+      config.protocol = window.location.protocol + '//';
+    }
+    jsonp(
+      [config.api_server || config.apiserver],
+      config.type_path,
+      config,
+      function (newConfig) {
+        var type = newConfig.type;
+        var init = function () {
+          config._extend(newConfig);
+          callback(new window.Geetest(config));
+        };
+        callbacks[type] = callbacks[type] || [];
+        var s = status[type] || 'init';
+        if (s === 'init') {
+          status[type] = 'loading';
+          callbacks[type].push(init);
+          load(
+            config.protocol,
+            newConfig.static_servers || newConfig.domains,
+            newConfig[type] || newConfig.path,
+            null,
+            function (err) {
+              if (err) {
+                status[type] = 'fail';
+                throwError('networkError', config);
+              } else {
+                status[type] = 'loaded';
+                var cbs = callbacks[type];
+                for (var i = 0, len = cbs.length; i < len; i = i + 1) {
+                  var cb = cbs[i];
+                  if (isFunction(cb)) {
+                    cb();
+                  }
+                }
+                callbacks[type] = [];
+              }
+            },
+          );
+        } else if (s === 'loaded') {
+          init();
+        } else if (s === 'fail') {
+          throwError('networkError', config);
+        } else if (s === 'loading') {
+          callbacks[type].push(init);
+        }
+      },
+    );
+  };
+  window.initGeetest = initGeetest;
+  return initGeetest;
+});

package/src/utils/index.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from 'events';
+import type { IMenu } from '@/components/BLayout/components/Menu';
+
+/**
+ * 检查menus数组是否带标签
+ * @param menus 菜单数组
+ * @returns boolean true表示有标签
+ */
+export function checkMenuVersion(menus: IMenu[]): boolean {
+  let hasTag = false;
+  for (let i = 0; i < menus.length; i++) {
+    const group = menus[i].sub_entry_list;
+    for (let j = 0; j < group.length; j++) {
+      const menu = group[j].tag_code;
+      if (menu !== 'STABLE') hasTag = true;
+    }
+  }
+  return hasTag;
+}
+
+export function browserType() {
+  const userAgent = navigator.userAgent;
+  if (userAgent.indexOf('Chrome') > -1 && userAgent.indexOf('Safari') > -1) {
+    return 'Chrome';
+  }
+  if (userAgent.indexOf('Safari') > -1 && userAgent.indexOf('Chrome') == -1) {
+    return 'Safari';
+  }
+  if (userAgent.indexOf('Firefox') > -1) {
+    return 'Firefox';
+  }
+  if (userAgent.indexOf('Edge') > -1) {
+    return 'Edge';
+  }
+  if (userAgent.indexOf('compatible') > -1 && userAgent.indexOf('MSIE') > -1) {
+    return 'IE';
+  }
+  if (userAgent.indexOf('Opera') > -1) {
+    return 'Opera';
+  }
+  return 'Other';
+}
+
+export const eventNames = {
+  USER_NAME: 'USER_NAME',
+  HIDE_MSG_TOOL: 'HIDE_MSG_TOOL',
+};
+export const eventEmiter = new EventEmitter();
+
+export const getMicroAppId = () => {
+  const pathname = window.location.pathname;
+  if (pathname.includes('/apps/')) {
+    return /\/apps\/([^\/]+)/.exec(pathname)?.[1];
+  } else {
+    return 'main-app';
+  }
+};
+
+export const curMicroAppName = () => {
+  const result = micApps()?.filter(
+    (app) => app.oem_micro_app_id === getMicroAppId()
+  );
+  if (result && result.length > 0) {
+    return result[0].micro_app_name;
+  }
+  return 'main-app';
+};
+
+export const curMicroAppCode = () => {
+  const result = micApps()?.filter(
+    (app) => app.oem_micro_app_id === getMicroAppId()
+  );
+  if (result && result.length > 0) {
+    return result[0].microAppCode;
+  }
+  return 'main-app';
+};
+
+export const micApps = () =>
+  window._SDF?.saasInfo?.apps?.map((element) => {
+    return {
+      ...element,
+      active_rule:
+        (window.location.pathname.match(/\/g\/\d+/)?.[0] || '') +
+        element.active_rule,
+    };
+  });
+
+export const saasApis = () => window._SDF?.saasInfo?.apis || [];

package/src/utils/theme/base.ts

@@ -0,0 +1,110 @@
+import type { MenuType } from 'src/components/BLayout/components/Menu';
+
+export const LIGHT = 'light';
+export const DARK = 'dark';
+
+export type Theme = typeof LIGHT | typeof DARK;
+
+export interface ColorConfig {
+  menuBg?: string;
+  menuText?: string;
+  menuBgExpand?: string;
+  menuTextExpand?: string;
+  menuBgActived?: string;
+  menuTextActived?: string;
+  menuSlideBg?: string;
+  menuSlideText?: string;
+  menuSlideBgActived?: string;
+  menuSlideTextActived?: string;
+  menuSlideBoundary?: string;
+  navigateBg?: string;
+  navigateText?: string;
+  navigateTextHover?: string;
+  navigateBoundary?: string;
+}
+
+export interface UserConfigItem {
+  hex: string;
+  a: number;
+}
+
+export type UserColorConfig = {
+  [p in keyof ColorConfig]?: UserConfigItem;
+};
+
+export type UserColorConfigWithTheme = Record<Theme, UserColorConfig>;
+
+export type UserColorConfigWithThemeAndMenu = Record<
+  MenuType,
+  UserColorConfigWithTheme
+>;
+
+interface DynamicTheme {
+  supportedTheme?: Theme | 'all';
+  primaryColor?: string | UserConfigItem;
+  primaryColorInAll?: string | UserConfigItem;
+  dynamicMenuColors?: UserColorConfigWithThemeAndMenu;
+}
+
+const dynamicTheme: DynamicTheme = (function getDynamicTheme() {
+  let config;
+  try {
+    config = JSON.parse(
+      window._SDF.saas.custom_configs?.find(
+        (item) => item.config_key === 'dynamic_theme',
+      )?.config_value_json,
+    );
+  } catch (e) {
+    config = {};
+  }
+  return config;
+})();
+
+function isSupportCssVariable() {
+  return !!dynamicTheme.primaryColor;
+}
+
+function isSupportLightDarkSwitch() {
+  return dynamicTheme.supportedTheme === 'all';
+}
+
+function getSupportedTheme() {
+  return dynamicTheme.supportedTheme;
+}
+function isSpecificTheme() {
+  return !!getSupportedTheme();
+}
+
+function getCssVarible() {
+  const { primaryColor, primaryColorInAll } = dynamicTheme;
+  return {
+    primaryColor,
+    primaryColorInAll,
+  };
+}
+
+function getDynamicMenuTheme() {
+  return dynamicTheme.dynamicMenuColors;
+}
+
+function getRenderTheme() {
+  const supportedTheme = getSupportedTheme();
+  const localTheme = localStorage.getItem('theme');
+  const validTheme = [LIGHT, DARK] as const;
+  if (supportedTheme === 'all') {
+    return validTheme.find((theme) => theme === localTheme) || LIGHT;
+  } else if (validTheme.includes(supportedTheme)) {
+    return supportedTheme;
+  }
+  return LIGHT;
+}
+
+export {
+  isSupportCssVariable,
+  isSupportLightDarkSwitch,
+  getSupportedTheme,
+  isSpecificTheme,
+  getCssVarible,
+  getDynamicMenuTheme,
+  getRenderTheme,
+};

package/src/utils/theme/changeCssVariable.ts

@@ -0,0 +1,157 @@
+/* eslint-disable import/prefer-default-export, prefer-destructuring */
+
+import { updateCSS } from 'rc-util/lib/Dom/dynamicCSS';
+import { TinyColor } from '@ctrl/tinycolor';
+import { generate } from '@ant-design/colors';
+import type { Theme } from './base';
+
+export interface ThemeColor {
+  primaryColor?: string;
+  infoColor?: string;
+  successColor?: string;
+  processingColor?: string;
+  errorColor?: string;
+  warningColor?: string;
+}
+
+const dynamicStyleMark = `${Date.now()}-${Math.random()}`;
+
+const dynamicId = (prefix = 'ant') => {
+  return `-${prefix}-${dynamicStyleMark}`;
+};
+
+//只会在dark环境下生成相关主题色的时候，消费。
+const backgroundColor = '#232E48';
+
+const themeColor = {
+  primaryColor: '#1890ff',
+  successColor: '#52c41a',
+  warningColor: '#faad14',
+  errorColor: '#ff4d4f',
+  infoColor: '#1890ff',
+};
+
+export function changeCssVarible(
+  setTheme: ThemeColor,
+  globalPrefixCls = 'ant',
+  themeVarint: Theme
+) {
+  const variables: Record<string, string> = {};
+  const themeInGenerate = themeVarint === 'dark' ? 'dark' : 'default';
+  const theme = Object.keys(themeColor).reduce((pre, val) => {
+    if (setTheme && setTheme[val]) {
+      return { ...pre, [val]: setTheme[val] };
+    } else {
+      return { ...pre, [val]: themeColor[val] };
+    }
+  }, {}) as typeof themeColor;
+
+  const formatColor = (
+    color: TinyColor,
+    updater?: (cloneColor: TinyColor) => TinyColor | undefined
+  ) => {
+    let clone = color.clone();
+    clone = updater?.(clone) || clone;
+    return clone.toRgbString();
+  };
+
+  const fillColor = (colorVal: string, type: string) => {
+    const baseColor = new TinyColor(colorVal);
+    const colorPalettes = generate(baseColor.toRgbString(), {
+      theme: themeInGenerate,
+      backgroundColor,
+    });
+
+    variables[`${type}-color`] = formatColor(baseColor);
+    variables[`${type}-color-disabled`] = colorPalettes[1];
+    variables[`${type}-color-hover`] = colorPalettes[4];
+    variables[`${type}-color-active`] = colorPalettes[6];
+    variables[`${type}-color-outline`] = baseColor
+      .clone()
+      .setAlpha(0.2)
+      .toRgbString();
+    variables[`${type}-color-deprecated-bg`] = colorPalettes[0];
+    variables[`${type}-color-deprecated-border`] = colorPalettes[2];
+  };
+
+  // ================ Primary Color ================
+  if (theme.primaryColor) {
+    fillColor(theme.primaryColor, 'primary');
+
+    const primaryColor = new TinyColor(theme.primaryColor);
+    const primaryColors = generate(primaryColor.toRgbString(), {
+      theme: themeInGenerate,
+      backgroundColor,
+    });
+
+    // Legacy - We should use semantic naming standard
+    primaryColors.forEach((color, index) => {
+      variables[`primary-${index + 1}`] = color;
+    });
+    // Deprecated
+    variables['primary-color-deprecated-l-35'] = formatColor(
+      primaryColor,
+      (c) => c.lighten(35)
+    );
+    variables['primary-color-deprecated-l-20'] = formatColor(
+      primaryColor,
+      (c) => c.lighten(20)
+    );
+    variables['primary-color-deprecated-t-20'] = formatColor(
+      primaryColor,
+      (c) => c.tint(20)
+    );
+    variables['primary-color-deprecated-t-50'] = formatColor(
+      primaryColor,
+      (c) => c.tint(50)
+    );
+    variables['primary-color-deprecated-f-12'] = formatColor(
+      primaryColor,
+      (c) => c.setAlpha(c.getAlpha() * 0.12)
+    );
+
+    const primaryActiveColor = new TinyColor(primaryColors[0]);
+    variables['primary-color-active-deprecated-f-30'] = formatColor(
+      primaryActiveColor,
+      (c) => c.setAlpha(c.getAlpha() * 0.3)
+    );
+    variables['primary-color-active-deprecated-d-02'] = formatColor(
+      primaryActiveColor,
+      (c) => c.darken(2)
+    );
+  }
+
+  // ================ Success Color ================
+  if (theme.successColor) {
+    fillColor(theme.successColor, 'success');
+  }
+
+  // ================ Warning Color ================
+  if (theme.warningColor) {
+    fillColor(theme.warningColor, 'warning');
+  }
+
+  // ================= Error Color =================
+  if (theme.errorColor) {
+    fillColor(theme.errorColor, 'error');
+  }
+
+  // ================= Info Color ==================
+  if (theme.infoColor) {
+    fillColor(theme.infoColor, 'info');
+  }
+
+  // Convert to css variables
+  const cssList = Object.keys(variables).map(
+    (key) => `--${globalPrefixCls}-${key}: ${variables[key]};`
+  );
+
+  updateCSS(
+    `
+  :root {
+    ${cssList.join('\n')}
+  }
+  `,
+    `${dynamicId(globalPrefixCls)}-dynamic-theme`
+  );
+}