fix: 修改文件名

app/web/component/layout/editor/index.ts

 import { Vue, Component, Prop, Watch } from 'vue-property-decorator';
 import iView from 'iview';
 import cherryUi from '@qg/cherry-ui';
-import VueContextMenu from '@editor/component/Contextmenu';
+import VueContextMenu from '@editor/component/Contextmenu/index';
 import 'iview/dist/styles/iview.css';
 import '@qg/cherry-ui/dist/cherry.css';
 

app/web/lib/Form/api/api.ts

+import Http from '@/service/http.service.ts';
+import Cookies from '@/service/cookieStorage.service.ts';
+import localStorage from '@/service/localStorage.service.ts';
+import { getParameterByName } from '@/service/utils.service.ts';
+
+const qs = require('qs');
+const ApiBaseUrl = 'http://passportapi.q-gp.com';
+const qApi = 'http://qapi.q-gp.com';
+
+export default {
+  getCaptcha() {
+    return Http.post(ApiBaseUrl + '/api/captcha');
+  },
+  sendVcode(phone, captcha, captchaId, flowFrom) {
+    const params = {
+      phoneNo: phone,
+      captchaId,
+      captchaValue: captcha,
+    };
+    if (flowFrom) {
+      params.smsMerchant = flowFrom;
+    }
+    return Http.post(ApiBaseUrl + '/api/sms/send_login_code_new_forH5', qs.stringify(params));
+  },
+  sendGtVcode(gt) {
+    return Http.post(ApiBaseUrl + '/api/sms/send_login_code_new_forH5', qs.stringify(gt));
+  },
+  fastLogin(phone, vcode, clickId, uniqueKey) {
+    const headers = {
+      Authorization: 'Verification ' + btoa(phone + ':' + vcode),
+    };
+
+    const params = {
+      channelId: 1,
+      createdFrom: getParameterByName('registerFrom') || 1,
+      key: 'xyqb',
+      btRegisterChannelId: '',
+      dimension: '',
+      click_id: clickId,
+      uniqueKey,
+    };
+    return Http.post(ApiBaseUrl + '/user/login/fastV1', qs.stringify(params), {
+      headers,
+    });
+  },
+  // 判断极验还是qg
+  verifyMode(clientType, phoneNo) {
+    return Http.post(ApiBaseUrl + '/api/captcha/new', { clientType, phoneNo });
+  },
+  goNext(params) {
+    return Http.post(ApiBaseUrl + '/platform/api/page/next', qs.stringify(params));
+  }
+};

app/web/lib/Form/index.vue

@@ -59,7 +59,7 @@
 import Storage from '@/service/localStorage.service.ts';
 import Cookies from '@/service/cookieStorage.service.ts';
 import { isPhone } from '@/service/utils.service.ts';
-import Api from './api/api.js';
+import Api from './api/api.ts';
 import { getParameterByName } from '@/service/utils.service.ts';
 // import './jy/jy.js';
 
@@ -121,7 +121,7 @@ export default {
   },
   mounted() {
     console.log('mounted');
-    require('./jy/jy.js');
+    require('./jy/jy.ts');
     sa = () => import('sa-sdk-javascript');
     this.verifyMode();
   },

app/web/lib/Form/jy/jy.ts

+/* 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');
+  }
+  const document = window.document;
+  const Math = window.Math;
+  const head = document.getElementsByTagName('head')[0];
+
+  function _Object(obj) {
+    this._obj = obj;
+  }
+
+  _Object.prototype = {
+    _each(process) {
+      const _obj = this._obj;
+      for (const k in _obj) {
+        if (_obj.hasOwnProperty(k)) {
+          process(k, _obj[k]);
+        }
+      }
+      return this;
+    }
+  };
+  function Config(config) {
+    const 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() {
+      const 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(obj) {
+      const self = this;
+      new _Object(obj)._each(function(key, value) {
+        self[key] = value;
+      });
+    }
+  };
+  const isNumber = function(value) {
+    return (typeof value === 'number');
+  };
+  const isString = function(value) {
+    return (typeof value === 'string');
+  };
+  const isBoolean = function(value) {
+    return (typeof value === 'boolean');
+  };
+  const isObject = function(value) {
+    return (typeof value === 'object' && value !== null);
+  };
+  const isFunction = function(value) {
+    return (typeof value === 'function');
+  };
+  const callbacks = {};
+  const status = {};
+  const random = function() {
+    return parseInt(Math.random() * 10000) + (new Date()).valueOf();
+  };
+  const loadScript = function(url, cb) {
+    const script = document.createElement('script');
+    script.charset = 'UTF-8';
+    script.async = true;
+    script.onerror = function() {
+      cb(true);
+    };
+    let 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);
+  };
+  const normalizeDomain = function(domain) {
+    return domain.replace(/^https?:\/\/|\/$/g, '');
+  };
+  const normalizePath = function(path) {
+    path = path.replace(/\/+/g, '/');
+    if (path.indexOf('/') !== 0) {
+      path = '/' + path;
+    }
+    return path;
+  };
+  const normalizeQuery = function(query) {
+    if (!query) {
+      return '';
+    }
+    let 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(/&$/, '');
+  };
+  const makeURL = function(protocol, domain, path, query) {
+    domain = normalizeDomain(domain);
+
+    let url = normalizePath(path) + normalizeQuery(query);
+    if (domain) {
+      url = protocol + domain + url;
+    }
+
+    return url;
+  };
+  const load = function(protocol, domains, path, query, cb) {
+    const tryRequest = function(at) {
+
+      const 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);
+  };
+  const 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;
+    }
+    const 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());
+      }
+    });
+  };
+  const throwError = function(errorType, config) {
+    const errors = {
+      networkError: '网络错误'
+    };
+    if (typeof config.onError === 'function') {
+      config.onError(errors[errorType]);
+    } else {
+      throw new Error(errors[errorType]);
+    }
+  };
+  const detect = function() {
+    return !!window.Geetest;
+  };
+  if (detect()) {
+    status.slide = 'loaded';
+  }
+  const initGeetest = function(userConfig, callback) {
+    const 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) {
+      const type = newConfig.type;
+      const init = function() {
+        config._extend(newConfig);
+        callback(new window.Geetest(config));
+      };
+      callbacks[type] = callbacks[type] || [];
+      const 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';
+            const cbs = callbacks[type];
+            for (let i = 0, len = cbs.length; i < len; i = i + 1) {
+              const 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;
+});

app/web/page/activity/component/helpers/DOM.ts

+let currentDir = 'auto';
+// let currentDir = "auto";
+
+function hasDocument() {
+  return (typeof document !== 'undefined');
+}
+
+function hasWindow() {
+  return (typeof window !== 'undefined');
+}
+
+export function getDocumentDir() {
+  if (!hasDocument()) {
+    return currentDir;
+  }
+  const direction = (typeof document.dir !== 'undefined') ?
+        document.dir :
+        document.getElementsByTagName('html')[0].getAttribute('dir');
+  return direction;
+}
+
+export function setDocumentDir(dir) {
+// export function setDocumentDir(dir){
+  if (!hasDocument) {
+    currentDir = dir;
+    return;
+  }
+
+  const html = document.getElementsByTagName('html')[0];
+  html.setAttribute('dir', dir);
+}
+
+export function addWindowEventListener(event, callback) {
+  if (!hasWindow) {
+
+    callback();
+    return;
+  }
+  window.addEventListener(event, callback);
+}
+
+export function removeWindowEventListener(event, callback) {
+  if (!hasWindow) {
+    return;
+  }
+  window.removeEventListener(event, callback);
+}

app/web/page/activity/component/helpers/draggableUtils.ts

+// Get {x, y} positions from event.
+export function getControlPosition(e) {
+  return offsetXYFromParentOf(e);
+}
+
+// Get from offsetParent
+export function offsetXYFromParentOf(evt) {
+  const offsetParent = evt.target.offsetParent || document.body;
+  const offsetParentRect = evt.offsetParent === document.body ? {left: 0, top: 0} : offsetParent.getBoundingClientRect();
+
+  const x = evt.clientX + offsetParent.scrollLeft - offsetParentRect.left;
+  const y = evt.clientY + offsetParent.scrollTop - offsetParentRect.top;
+
+    /*const x = Math.round(evt.clientX + offsetParent.scrollLeft - offsetParentRect.left);
+    const y = Math.round(evt.clientY + offsetParent.scrollTop - offsetParentRect.top);*/
+
+  return {x, y};
+}
+
+// Create an data object exposed by <DraggableCore>'s events
+export function createCoreData(lastX, lastY, x, y) {
+    // State changes are often (but not always!) async. We want the latest value.
+  const isStart = !isNum(lastX);
+
+  if (isStart) {
+        // If this is our first move, use the x and y as last coords.
+    return {
+      deltaX: 0, deltaY: 0,
+      lastX: x, lastY: y,
+      x, y
+    };
+  } else {
+        // Otherwise calculate proper values.
+    return {
+      deltaX: x - lastX, deltaY: y - lastY,
+      lastX, lastY,
+      x, y
+    };
+  }
+}
+
+function isNum(num)  {
+  return typeof num === 'number' && !isNaN(num);
+}

app/web/page/activity/component/helpers/responsiveUtils.ts

+// @flow
+
+import {cloneLayout, compact, correctBounds} from './utils';
+
+// import type {Layout} from './utils';
+// export type ResponsiveLayout = {lg, md, sm, xs, xxs};
+// type Breakpoint = string;
+// type Breakpoints = {lg, md, sm, xs, xxs};
+
+/**
+ * Given a width, find the highest breakpoint that matches is valid for it (width > breakpoint).
+ *
+ * @param  {Object} breakpoints Breakpoints object (e.g. {lg: 1200, md: 960, ...})
+ * @param  {Number} width Screen width.
+ * @return {String}       Highest breakpoint that is less than width.
+ */
+export function getBreakpointFromWidth(breakpoints, width) {
+  const sorted = sortBreakpoints(breakpoints);
+  let matching = sorted[0];
+  for (let i = 1, len = sorted.length; i < len; i++) {
+    const breakpointName = sorted[i];
+    if (width > breakpoints[breakpointName]) { matching = breakpointName; }
+  }
+  return matching;
+}
+
+/**
+ * Given a breakpoint, get the # of cols set for it.
+ * @param  {String} breakpoint Breakpoint name.
+ * @param  {Object} cols       Map of breakpoints to cols.
+ * @return {Number}            Number of cols.
+ */
+export function getColsFromBreakpoint(breakpoint, cols) {
+  if (!cols[breakpoint]) {
+    throw new Error('ResponsiveGridLayout: `cols` entry for breakpoint ' + breakpoint + ' is missing!');
+  }
+  return cols[breakpoint];
+}
+
+/**
+ * Given existing layouts and a new breakpoint, find or generate a new layout.
+ *
+ * This finds the layout above the new one and generates from it, if it exists.
+ *
+ * @param  {Array} orgLayout     Original layout.
+ * @param  {Object} layouts     Existing layouts.
+ * @param  {Array} breakpoints All breakpoints.
+ * @param  {String} breakpoint New breakpoint.
+ * @param  {String} breakpoint Last breakpoint (for fallback).
+ * @param  {Number} cols       Column count at new breakpoint.
+ * @param  {Boolean} verticalCompact Whether or not to compact the layout
+ *   vertically.
+ * @return {Array}             New layout.
+ */
+export function findOrGenerateResponsiveLayout(orgLayout, layouts, breakpoints,
+                                               breakpoint, lastBreakpoint,
+                                               cols, verticalCompact) {
+  // If it already exists, just return it.
+  if (layouts[breakpoint]) { return cloneLayout(layouts[breakpoint]); }
+  // Find or generate the next layout
+  let layout = orgLayout;
+
+  const breakpointsSorted = sortBreakpoints(breakpoints);
+  const breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));
+  for (let i = 0, len = breakpointsAbove.length; i < len; i++) {
+    const b = breakpointsAbove[i];
+    if (layouts[b]) {
+      layout = layouts[b];
+      break;
+    }
+  }
+  layout = cloneLayout(layout || []); // clone layout so we don't modify existing items
+  return compact(correctBounds(layout, {cols}), verticalCompact);
+}
+
+export function generateResponsiveLayout(layout, breakpoints,
+                                         breakpoint, lastBreakpoint,
+                                         cols, verticalCompact) {
+  // If it already exists, just return it.
+  /*if (layouts[breakpoint]) return cloneLayout(layouts[breakpoint]);
+  // Find or generate the next layout
+  let layout = layouts[lastBreakpoint];*/
+    /*const breakpointsSorted = sortBreakpoints(breakpoints);
+  const breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));
+  for (let i = 0, len = breakpointsAbove.length; i < len; i++) {
+    const b = breakpointsAbove[i];
+    if (layouts[b]) {
+      layout = layouts[b];
+      break;
+    }
+  }*/
+  layout = cloneLayout(layout || []); // clone layout so we don't modify existing items
+  return compact(correctBounds(layout, {cols}), verticalCompact);
+}
+
+/**
+ * Given breakpoints, return an array of breakpoints sorted by width. This is usually
+ * e.g. ['xxs', 'xs', 'sm', ...]
+ *
+ * @param  {Object} breakpoints Key/value pair of breakpoint names to widths.
+ * @return {Array}              Sorted breakpoints.
+ */
+export function sortBreakpoints(breakpoints) {
+  const keys = Object.keys(breakpoints);
+  return keys.sort(function(a, b) {
+    return breakpoints[a] - breakpoints[b];
+  });
+}

app/web/page/editor/component/Contextmenu/constant.ts

+export const SUBMENU_X_OFFSET = 3;
+export const SUBMENU_Y_OFFSET = -8;
+export const SUBMENU_OPEN_TREND_LEFT = 'left';
+export const SUBMENU_OPEN_TREND_RIGHT = 'right';
+export const COMPONENT_NAME = 'contextmenu-submenu';

app/web/page/editor/component/Contextmenu/index.ts

+
+import Vue from 'vue';
+import Contextmenu from './components/Contextmenu';
+import Submenu from './components/Submenu';
+import { COMPONENT_NAME } from './constant';
+
+const ContextmenuConstructor = Vue.extend(Contextmenu);
+Vue.component(COMPONENT_NAME, Submenu);
+
+function install(Vue) {
+  let lastInstance = null;
+  const ContextmenuProxy = function(options) {
+    const instance = new ContextmenuConstructor();
+    instance.items = options.items;
+    instance.position.x = options.x || 0;
+    instance.position.y = options.y || 0;
+    if (options.event) {
+      instance.position.x = options.event.clientX;
+      instance.position.y = options.event.clientY;
+    }
+    instance.customClass = options.customClass;
+    options.minWidth && (instance.style.minWidth = options.minWidth);
+    options.zIndex && (instance.style.zIndex = options.zIndex);
+    ContextmenuProxy.destroy();
+    lastInstance = instance;
+    instance.$mount();
+  };
+  ContextmenuProxy.destroy = function() {
+    if (lastInstance) {
+      lastInstance.$destroy();
+      lastInstance = null;
+    }
+  };
+  Vue.prototype.$contextmenu = ContextmenuProxy;
+}
+
+if (window && window.Vue) {
+  install(window.Vue);
+}
+
+export default {
+  install
+};

app/web/page/editor/component/Contextmenu/util.ts

+export function hasClass(el, className) {
+  if (!className) {
+    return true;
+  }
+  if (!el || !el.className || typeof el.className !== 'string') {
+    return false;
+  }
+  for (const cn of el.className.split(/\s+/)) {
+    if (cn === className) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function getElementsByClassName(className) {
+  const els = [];
+  for (const el of document.getElementsByClassName(className) || []) {
+    els.push(el);
+  }
+  return els;
+}
+
+export function uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}