ibsp-fg-page 4.0.2

package/src/libs/ibspForm/demo.html

@@ -0,0 +1,10 @@
+<meta charset="utf-8">
+<title>FormMaking demo</title>
+<script src="./FormMaking.umd.js"></script>
+
+<link rel="stylesheet" href="./FormMaking.css">
+
+
+<script>
+console.log(FormMaking)
+</script>

package/src/libs/uni/uni.webview.1.5.5.js

@@ -0,0 +1,58 @@
+!function(e, n) {
+  'object' === typeof exports && 'undefined' !== typeof module ? module.exports = n() : 'function' === typeof define && define.amd ? define(n) : (e = e || self).uni = n()
+}(this, (function() {
+  'use strict'; try {
+    var e = {}; Object.defineProperty(e, 'passive', { get: function() {
+      !0
+    } }), window.addEventListener('test-passive', null, e)
+  } catch (e) {} var n = Object.prototype.hasOwnProperty; function t(e, t) {
+    return n.call(e, t)
+  } var i = [], a = function(e, n) {
+      var t = { options: { timestamp: +new Date }, name: e, arg: n }; if (window.__dcloud_weex_postMessage || window.__dcloud_weex_) {
+        if ('postMessage' === e) {
+          var a = { data: [n] }; return window.__dcloud_weex_postMessage ? window.__dcloud_weex_postMessage(a) : window.__dcloud_weex_.postMessage(JSON.stringify(a))
+        } var o = { type: 'WEB_INVOKE_APPSERVICE', args: { data: t, webviewIds: i } }; window.__dcloud_weex_postMessage ? window.__dcloud_weex_postMessageToService(o) : window.__dcloud_weex_.postMessageToService(JSON.stringify(o))
+      } if (!window.plus) return window.parent.postMessage({ type: 'WEB_INVOKE_APPSERVICE', data: t, pageId: '' }, '*'); if (0 === i.length) {
+        var r = plus.webview.currentWebview(); if (!r) throw new Error('plus.webview.currentWebview() is undefined'); var d = r.parent(), s = ''; s = d ? d.id : r.id, i.push(s)
+      } if (plus.webview.getWebviewById('__uniapp__service'))plus.webview.postMessageToUniNView({ type: 'WEB_INVOKE_APPSERVICE', args: { data: t, webviewIds: i } }, '__uniapp__service'); else {
+        var w = JSON.stringify(t); plus.webview.getLaunchWebview().evalJS('UniPlusBridge.subscribeHandler("'.concat('WEB_INVOKE_APPSERVICE', '",').concat(w, ',')
+          .concat(JSON.stringify(i), ');'))
+      }
+    }, o = { navigateTo: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, n = e.url; a('navigateTo', { url: encodeURI(n) })
+    }, navigateBack: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, n = e.delta; a('navigateBack', { delta: parseInt(n) || 1 })
+    }, switchTab: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, n = e.url; a('switchTab', { url: encodeURI(n) })
+    }, reLaunch: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, n = e.url; a('reLaunch', { url: encodeURI(n) })
+    }, redirectTo: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}, n = e.url; a('redirectTo', { url: encodeURI(n) })
+    }, getEnv: function(e) {
+      window.plus ? e({ plus: !0 }) : e({ h5: !0 })
+    }, postMessage: function() {
+      var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}; a('postMessage', e.data || {})
+    } }, r = /uni-app/i.test(navigator.userAgent), d = /Html5Plus/i.test(navigator.userAgent), s = /complete|loaded|interactive/; var w = window.my && navigator.userAgent.indexOf('AlipayClient') > -1; var u = window.swan && window.swan.webView && /swan/i.test(navigator.userAgent); var c = window.qq && window.qq.miniProgram && /QQ/i.test(navigator.userAgent) && /miniProgram/i.test(navigator.userAgent); var g = window.tt && window.tt.miniProgram && /toutiaomicroapp/i.test(navigator.userAgent); var v = window.wx && window.wx.miniProgram && /micromessenger/i.test(navigator.userAgent) && /miniProgram/i.test(navigator.userAgent); var p = window.qa && /quickapp/i.test(navigator.userAgent); for (var l, _ = function() {
+      window.UniAppJSBridge = !0, document.dispatchEvent(new CustomEvent('UniAppJSBridgeReady', { bubbles: !0, cancelable: !0 }))
+    }, f = [function(e) {
+      if (r || d) return window.__dcloud_weex_postMessage || window.__dcloud_weex_ ? document.addEventListener('DOMContentLoaded', e) : window.plus && s.test(document.readyState) ? setTimeout(e, 0) : document.addEventListener('plusready', e), o
+    }, function(e) {
+      if (v) return window.WeixinJSBridge && window.WeixinJSBridge.invoke ? setTimeout(e, 0) : document.addEventListener('WeixinJSBridgeReady', e), window.wx.miniProgram
+    }, function(e) {
+      if (c) return window.QQJSBridge && window.QQJSBridge.invoke ? setTimeout(e, 0) : document.addEventListener('QQJSBridgeReady', e), window.qq.miniProgram
+    }, function(e) {
+      if (w) {
+        document.addEventListener('DOMContentLoaded', e); var n = window.my; return { navigateTo: n.navigateTo, navigateBack: n.navigateBack, switchTab: n.switchTab, reLaunch: n.reLaunch, redirectTo: n.redirectTo, postMessage: n.postMessage, getEnv: n.getEnv }
+      }
+    }, function(e) {
+      if (u) return document.addEventListener('DOMContentLoaded', e), window.swan.webView
+    }, function(e) {
+      if (g) return document.addEventListener('DOMContentLoaded', e), window.tt.miniProgram
+    }, function(e) {
+      if (p) {
+        window.QaJSBridge && window.QaJSBridge.invoke ? setTimeout(e, 0) : document.addEventListener('QaJSBridgeReady', e); var n = window.qa; return { navigateTo: n.navigateTo, navigateBack: n.navigateBack, switchTab: n.switchTab, reLaunch: n.reLaunch, redirectTo: n.redirectTo, postMessage: n.postMessage, getEnv: n.getEnv }
+      }
+    }, function(e) {
+      return document.addEventListener('DOMContentLoaded', e), o
+    }], m = 0; m < f.length && !(l = f[m](_)); m++);l || (l = {}); var E = 'undefined' !== typeof uni ? uni : {}; if (!E.navigateTo) for (var b in l)t(l, b) && (E[b] = l[b]); return E.webView = l, E
+}));

package/src/libs/vanilla-js-wheel-zoom/calculator.js

@@ -0,0 +1,103 @@
+import { getElementPosition, getPageScrollLeft, getPageScrollTop } from './toolkit';
+
+/**
+ * @param {WZoomViewport} viewport
+ * @param {WZoomContent} content
+ * @param {string} align
+ * @returns {number[]}
+ */
+export function calculateAlignPoint(viewport, content, align) {
+  let pointX = 0;
+  let pointY = 0;
+
+  switch (align) {
+  case 'top':
+    pointY = (content.currentHeight - viewport.originalHeight) / 2;
+    break;
+  case 'right':
+    pointX = (content.currentWidth - viewport.originalWidth) / 2 * -1;
+    break;
+  case 'bottom':
+    pointY = (content.currentHeight - viewport.originalHeight) / 2 * -1;
+    break;
+  case 'left':
+    pointX = (content.currentWidth - viewport.originalWidth) / 2;
+    break;
+  }
+
+  return [pointX, pointY];
+}
+
+/**
+ * @param {WZoomViewport} viewport
+ * @param {WZoomContent} content
+ * @param {string} align
+ * @returns {number[]}
+ */
+export function calculateCorrectPoint(viewport, content, align) {
+  let pointX = Math.max(0, (viewport.originalWidth - content.currentWidth) / 2);
+  let pointY = Math.max(0, (viewport.originalHeight - content.currentHeight) / 2);
+
+  switch (align) {
+  case 'top':
+    pointY = 0;
+    break;
+  case 'right':
+    pointX = 0;
+    break;
+  case 'bottom':
+    pointY = pointY * 2;
+    break;
+  case 'left':
+    pointX = pointX * 2;
+    break;
+  }
+
+  return [pointX, pointY];
+}
+
+/**
+ * @returns {number}
+ */
+export function calculateContentShift(axisValue, axisScroll, axisViewportPosition, axisContentPosition, originalViewportSize, contentSizeRatio) {
+  const viewportShift = axisValue + axisScroll - axisViewportPosition;
+  const centerViewportShift = originalViewportSize / 2 - viewportShift;
+  const centerContentShift = centerViewportShift + axisContentPosition;
+
+  return centerContentShift * contentSizeRatio - centerContentShift + axisContentPosition;
+}
+
+export function calculateContentMaxShift(align, originalViewportSize, correctCoordinate, size, shift) {
+  switch (align) {
+  case 'left':
+    if (size / 2 - shift < originalViewportSize / 2) {
+      shift = (size - originalViewportSize) / 2;
+    }
+    break;
+  case 'right':
+    if (size / 2 + shift < originalViewportSize / 2) {
+      shift = (size - originalViewportSize) / 2 * -1;
+    }
+    break;
+  default:
+    if ((size - originalViewportSize) / 2 + correctCoordinate < Math.abs(shift)) {
+      const positive = shift < 0 ? -1 : 1;
+      shift = ((size - originalViewportSize) / 2 + correctCoordinate) * positive;
+    }
+  }
+
+  return shift;
+}
+
+/**
+ * @param {WZoomViewport} viewport
+ * @returns {{x: number, y: number}}
+ */
+export function calculateViewportCenter(viewport) {
+  const viewportPosition = getElementPosition(viewport.$element);
+
+  return {
+    x: viewportPosition.left + (viewport.originalWidth / 2) - getPageScrollLeft(),
+    y: viewportPosition.top + (viewport.originalHeight / 2) - getPageScrollTop(),
+  };
+}

package/src/libs/vanilla-js-wheel-zoom/default-options.js

@@ -0,0 +1,52 @@
+/** @type {WZoomOptions} */
+export const wZoomDefaultOptions = {
+  // type content: `image` - only one image, `html` - any HTML content
+  type: 'image',
+  // for type `image` computed auto (if width set null), for type `html` need set real html content width, else computed auto
+  width: null,
+  // for type `image` computed auto (if height set null), for type `html` need set real html content height, else computed auto
+  height: null,
+  // minimum allowed proportion of scale (computed auto if null)
+  minScale: null,
+  // maximum allowed proportion of scale (1 = 100% content size)
+  maxScale: 1,
+  // content resizing speed
+  speed: 1.1,
+  // zoom to maximum (minimum) size on click
+  zoomOnClick: true,
+  // zoom to maximum (minimum) size on double click
+  zoomOnDblClick: false,
+  // smooth extinction
+  smoothTime: .25,
+  // align content `center`, `left`, `top`, `right`, `bottom`
+  alignContent: 'center',
+  // ******************** //
+  disableWheelZoom: false,
+  // option to reverse wheel direction
+  reverseWheelDirection: false,
+  // ******************** //
+  // drag scrollable content
+  dragScrollable: true,
+};
+
+/**
+ * @typedef WZoomOptions
+ * @type {Object}
+ * @property {string} type
+ * @property {?number} width
+ * @property {?number} height
+ * @property {?number} minScale
+ * @property {number} maxScale
+ * @property {number} speed
+ * @property {boolean} zoomOnClick
+ * @property {boolean} zoomOnDblClick
+ * @property {number} smoothTime
+ * @property {string} alignContent
+ * @property {boolean} disableWheelZoom
+ * @property {boolean} reverseWheelDirection
+ * @property {boolean} dragScrollable
+ * @property {number} smoothTimeDrag
+ * @property {?Function} onGrab
+ * @property {?Function} onMove
+ * @property {?Function} onDrop
+ */

package/src/libs/vanilla-js-wheel-zoom/observers/AbstractObserver.js

@@ -0,0 +1,51 @@
+class AbstractObserver {
+  /**
+     * @constructor
+     */
+  constructor() {
+    /** @type {Object<string, (event: Event) => void>} */
+    this.subscribes = {};
+  }
+
+  /**
+     * @param {string} eventType
+     * @param {(event: Event) => void} eventHandler
+     * @returns {AbstractObserver}
+     */
+  on(eventType, eventHandler) {
+    if (!(eventType in this.subscribes)) {
+      this.subscribes[eventType] = [];
+    }
+
+    this.subscribes[eventType].push(eventHandler);
+
+    return this;
+  }
+
+  destroy(key) {
+    if (key) {
+      delete this.subscribes[key];
+      return
+    }
+    for (let key in this) {
+      if (this.hasOwnProperty(key)) {
+        this[key] = null;
+      }
+    }
+  }
+
+  /**
+     * @param {string} eventType
+     * @param {Event} event
+     * @protected
+     */
+  _run(eventType, event) {
+    if (this.subscribes[eventType]) {
+      for (const eventHandler of this.subscribes[eventType]) {
+        eventHandler(event);
+      }
+    }
+  }
+}
+
+export default AbstractObserver;

package/src/libs/vanilla-js-wheel-zoom/observers/DragScrollableObserver.js

@@ -0,0 +1,103 @@
+import { on, off, eventClientX, eventClientY, isTouch } from '../toolkit';
+import AbstractObserver from './AbstractObserver';
+
+export const EVENT_GRAB = 'grab';
+export const EVENT_MOVE = 'move';
+export const EVENT_DROP = 'drop';
+
+class DragScrollableObserver extends AbstractObserver {
+  /**
+     * @param {HTMLElement} target
+     * @constructor
+     */
+  constructor(target) {
+    super();
+
+    this.target = target;
+
+    this.moveTimer = null;
+    this.coordinates = null;
+    this.coordinatesShift = null;
+
+    // check if we're using a touch screen
+    this.isTouch = isTouch();
+    // switch to touch events if using a touch screen
+    this.events = this.isTouch
+      ? { grab: 'touchstart', move: 'touchmove', drop: 'touchend' }
+      : { grab: 'mousedown', move: 'mousemove', drop: 'mouseup' };
+    // for the touch screen we set the parameter forcibly
+    this.events.options = this.isTouch ? { passive: false } : false;
+
+    this._dropHandler = this._dropHandler.bind(this);
+    this._grabHandler = this._grabHandler.bind(this);
+    this._moveHandler = this._moveHandler.bind(this);
+
+    on(this.target, this.events.grab, this._grabHandler, this.events.options);
+  }
+
+  destroy() {
+    off(this.target, this.events.grab, this._grabHandler, this.events.options);
+
+    super.destroy();
+  }
+
+  /**
+     * @param {Event|TouchEvent|MouseEvent} event
+     * @private
+     */
+  _grabHandler(event) {
+    // if touch started (only one finger) or pressed left mouse button
+    if ((this.isTouch && event.touches.length === 1) || event.buttons === 1) {
+      this.coordinates = { x: eventClientX(event), y: eventClientY(event) };
+      this.coordinatesShift = { x: 0, y: 0 };
+
+      on(document, this.events.drop, this._dropHandler, this.events.options);
+      on(document, this.events.move, this._moveHandler, this.events.options);
+
+      this._run(EVENT_GRAB, event);
+    }
+  }
+
+  /**
+     * @param {Event} event
+     * @private
+     */
+  _dropHandler(event) {
+    off(document, this.events.drop, this._dropHandler);
+    off(document, this.events.move, this._moveHandler);
+
+    this._run(EVENT_DROP, event);
+  }
+
+  /**
+     * @param {Event|TouchEvent} event
+     * @private
+     */
+  _moveHandler(event) {
+    // so that it does not move when the touch screen and more than one finger
+    if (this.isTouch && event.touches.length > 1) return false;
+
+    const { coordinatesShift, coordinates } = this;
+
+    // change of the coordinate of the mouse cursor along the X/Y axis
+    coordinatesShift.x = eventClientX(event) - coordinates.x;
+    coordinatesShift.y = eventClientY(event) - coordinates.y;
+
+    coordinates.x = eventClientX(event);
+    coordinates.y = eventClientY(event);
+
+    clearTimeout(this.moveTimer);
+
+    // reset shift if cursor stops
+    this.moveTimer = setTimeout(() => {
+      coordinatesShift.x = 0;
+      coordinatesShift.y = 0;
+    }, 50);
+
+    event.data = { ...event.data || {}, x: coordinatesShift.x, y: coordinatesShift.y };
+
+    this._run(EVENT_MOVE, event);
+  }
+}
+
+export default DragScrollableObserver;

package/src/libs/vanilla-js-wheel-zoom/observers/InteractionObserver.js

@@ -0,0 +1,122 @@
+import { eventClientX, eventClientY, isTouch, off, on } from '../toolkit';
+import AbstractObserver from './AbstractObserver';
+
+export const EVENT_CLICK = 'click';
+export const EVENT_DBLCLICK = 'dblclick';
+export const EVENT_WHEEL = 'wheel';
+
+class InteractionObserver extends AbstractObserver {
+  /**
+     * @param {HTMLElement} target
+     * @constructor
+     */
+  constructor(target) {
+    super();
+
+    this.target = target;
+
+    this.coordsOnDown = null;
+    this.pressingTimeout = null;
+    this.firstClick = true;
+
+    // check if we're using a touch screen
+    this.isTouch = isTouch();
+    // switch to touch events if using a touch screen
+    this.events = this.isTouch
+      ? { down: 'touchstart', up: 'touchend' }
+      : { down: 'mousedown', up: 'mouseup' };
+    // if using touch screen tells the browser that the default action will not be undone
+    this.events.options = this.isTouch ? { passive: true } : false;
+
+    this._downHandler = this._downHandler.bind(this);
+    this._upHandler = this._upHandler.bind(this);
+    this._wheelHandler = this._wheelHandler.bind(this);
+
+    on(this.target, this.events.down, this._downHandler, this.events.options);
+    on(this.target, this.events.up, this._upHandler, this.events.options);
+    // on(this.target, EVENT_WHEEL, this._wheelHandler);
+  }
+
+  openWheelEvent = ()=> {
+    on(this.target, EVENT_WHEEL, this._wheelHandler);
+  }
+  closeWheelEvent = ()=> {
+    off(this.target, EVENT_WHEEL, this._wheelHandler, this.events.options);
+    super.destroy(EVENT_WHEEL);
+  }
+
+  destroy() {
+    off(this.target, this.events.down, this._downHandler, this.events.options);
+    off(this.target, this.events.up, this._upHandler, this.events.options);
+    off(this.target, EVENT_WHEEL, this._wheelHandler, this.events.options);
+
+    super.destroy();
+  }
+
+
+  /**
+     * @param {TouchEvent|MouseEvent|PointerEvent} event
+     * @private
+     */
+  _downHandler(event) {
+    this.coordsOnDown = null;
+
+    if ((this.isTouch && event.touches.length === 1) || event.buttons === 1) {
+      this.coordsOnDown = { x: eventClientX(event), y: eventClientY(event) };
+    }
+
+    clearTimeout(this.pressingTimeout);
+  }
+
+  /**
+     * @param {TouchEvent|MouseEvent|PointerEvent} event
+     * @private
+     */
+  _upHandler(event) {
+    const delay = 200;
+    const setTimeoutInner = this.subscribes[EVENT_DBLCLICK]
+      ? setTimeout
+      : (cb, delay) => cb();
+
+    if (this.firstClick) {
+      this.firstClick = false;
+
+      this.pressingTimeout = setTimeoutInner(() => {
+        if (!this._isDetectedShift(event)) {
+          this._run(EVENT_CLICK, event);
+        }
+
+        this.firstClick = true;
+      }, delay);
+    } else {
+      this.pressingTimeout = setTimeoutInner(() => {
+        if (!this._isDetectedShift(event)) {
+          this._run(EVENT_DBLCLICK, event);
+        }
+
+        this.firstClick = true;
+      }, delay / 2);
+    }
+  }
+
+  /**
+     * @param {WheelEvent} event
+     * @private
+     */
+  _wheelHandler(event) {
+    this._run(EVENT_WHEEL, event);
+  }
+
+  /**
+     * @param {TouchEvent|MouseEvent|PointerEvent} event
+     * @return {boolean}
+     * @private
+     */
+  _isDetectedShift(event) {
+    return !(this.coordsOnDown &&
+            this.coordsOnDown.x === eventClientX(event) &&
+            this.coordsOnDown.y === eventClientY(event));
+  }
+}
+
+export default InteractionObserver;

package/src/libs/vanilla-js-wheel-zoom/observers/PinchToZoomObserver.js

@@ -0,0 +1,86 @@
+import { off, on } from '../toolkit';
+import AbstractObserver from './AbstractObserver';
+
+export const EVENT_PINCH_TO_ZOOM = 'pinchtozoom';
+
+const SHIFT_DECIDE_THAT_MOVE_STARTED = 5;
+
+class PinchToZoomObserver extends AbstractObserver {
+  /**
+     * @param {HTMLElement} target
+     * @constructor
+     */
+  constructor(target) {
+    super();
+
+    this.target = target;
+
+    this.fingersHypot = null;
+    this.zoomPinchWasDetected = false;
+
+    this._touchMoveHandler = this._touchMoveHandler.bind(this);
+    this._touchEndHandler = this._touchEndHandler.bind(this);
+
+    on(this.target, 'touchmove', this._touchMoveHandler);
+    on(this.target, 'touchend', this._touchEndHandler);
+  }
+
+  destroy() {
+    off(this.target, 'touchmove', this._touchMoveHandler);
+    off(this.target, 'touchend', this._touchEndHandler);
+
+    super.destroy();
+  }
+
+  /**
+     * @param {TouchEvent|PointerEvent} event
+     * @private
+     */
+  _touchMoveHandler(event) {
+    // detect two fingers
+    if (event.targetTouches.length === 2) {
+      const pageX1 = event.targetTouches[0].clientX;
+      const pageY1 = event.targetTouches[0].clientY;
+
+      const pageX2 = event.targetTouches[1].clientX;
+      const pageY2 = event.targetTouches[1].clientY;
+
+      // Math.hypot() analog
+      const fingersHypotNew = Math.round(Math.sqrt(
+        Math.pow(Math.abs(pageX1 - pageX2), 2) +
+                Math.pow(Math.abs(pageY1 - pageY2), 2)
+      ));
+
+      let direction = 0;
+      if (fingersHypotNew > this.fingersHypot + SHIFT_DECIDE_THAT_MOVE_STARTED) direction = -1;
+      if (fingersHypotNew < this.fingersHypot - SHIFT_DECIDE_THAT_MOVE_STARTED) direction = 1;
+
+      if (direction !== 0) {
+        if (this.fingersHypot !== null || direction === 1) {
+          // middle position between fingers
+          const clientX = Math.min(pageX1, pageX2) + (Math.abs(pageX1 - pageX2) / 2);
+          const clientY = Math.min(pageY1, pageY2) + (Math.abs(pageY1 - pageY2) / 2);
+
+          event.data = { ...event.data || {}, clientX, clientY, direction };
+
+          this._run(EVENT_PINCH_TO_ZOOM, event);
+        }
+
+        this.fingersHypot = fingersHypotNew;
+        this.zoomPinchWasDetected = true;
+      }
+    }
+  }
+
+  /**
+     * @private
+     */
+  _touchEndHandler() {
+    if (this.zoomPinchWasDetected) {
+      this.fingersHypot = null;
+      this.zoomPinchWasDetected = false;
+    }
+  }
+}
+
+export default PinchToZoomObserver;