@opentiny/vue-renderless 3.1.0-alpha.0

package/notify/index.js

@@ -0,0 +1,91 @@
+var _this = this;
+import { KEY_CODE } from '@opentiny/vue-renderless/common';
+import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
+import PopupManager from '@opentiny/vue-renderless/common/deps/popup-manager';
+export var startTimer = function startTimer(_ref) {
+  var api = _ref.api,
+    state = _ref.state;
+  return function () {
+    if (state.duration > 0) {
+      state.timer = setTimeout(function () {
+        !state.closed && api.close();
+      }, state.duration);
+    }
+  };
+};
+export var clearTimer = function clearTimer(state) {
+  return function () {
+    clearTimeout(state.timer);
+    state.timer = null;
+  };
+};
+export var click = function click(_ref2) {
+  var emit = _ref2.emit,
+    state = _ref2.state;
+  return function () {
+    typeof state.onClick === 'function' && _this.onClick();
+    emit('click', '');
+  };
+};
+export var close = function close(_ref3) {
+  var state = _ref3.state,
+    props = _ref3.props;
+  return function () {
+    if (!props.beforeClose || typeof props.beforeClose === 'function' && props.beforeClose()) {
+      typeof props.onClose === 'function' && props.onClose();
+      state.closed = true;
+    }
+  };
+};
+export var watchClosed = function watchClosed(state) {
+  return function (value) {
+    if (value) {
+      state.visible = false;
+    }
+  };
+};
+export var getTypeClass = function getTypeClass(constants) {
+  return function (state) {
+    return state.type && constants[state.type.toUpperCase()] ? "icon-".concat(constants[state.type]) : '';
+  };
+};
+export var getOffsetStyle = function getOffsetStyle(state) {
+  var side = {};
+  side[state.verticalProperty] = "".concat(state.verticalOffset, "px");
+  return side;
+};
+export var getZindex = function getZindex() {
+  return PopupManager.nextZIndex();
+};
+export var getPositionSide = function getPositionSide(state) {
+  return /^top-/.test(state.position) ? 'top' : 'bottom';
+};
+export var bindKeyDown = function bindKeyDown(_ref4) {
+  var api = _ref4.api,
+    state = _ref4.state;
+  return function (event) {
+    if (event.keyCode === KEY_CODE.Delete || event.keyCode === KEY_CODE.Backspace) {
+      api.clearTimer();
+    } else if (event.keyCode === KEY_CODE.Escape) {
+      !state.closed && api.close();
+    } else {
+      api.startTimer();
+    }
+  };
+};
+export var bindEvent = function bindEvent(_ref5) {
+  var api = _ref5.api,
+    state = _ref5.state;
+  return function () {
+    if (state.timer) {
+      api.clearTimer();
+    }
+    api.startTimer();
+    on(document, 'keydown', api.bindKeyDown);
+  };
+};
+export var unBindEvent = function unBindEvent(api) {
+  return function () {
+    return off(document, 'keydown', api.bindKeyDown);
+  };
+};

package/notify/vue.js

@@ -0,0 +1,67 @@
+import { clearTimer, startTimer, close, bindEvent, unBindEvent, click, watchClosed, getOffsetStyle, getPositionSide, getZindex } from './index';
+export var api = ['state', 'clearTimer', 'startTimer', 'close', 'bindEvent', 'unBindEvent', 'click', 'watchClosed', 'getOffsetStyle', 'getPositionSide', 'getZindex'];
+export var renderless = function renderless(props, _ref, _ref2) {
+  var computed = _ref.computed,
+    onBeforeUnmount = _ref.onBeforeUnmount,
+    onMounted = _ref.onMounted,
+    reactive = _ref.reactive,
+    watch = _ref.watch;
+  var emit = _ref2.emit;
+  var api = {};
+  var state = reactive({
+    timer: null,
+    closed: false,
+    visible: true,
+    duration: computed(function () {
+      return props.duration;
+    }),
+    showClose: true,
+    verticalOffset: 0,
+    position: computed(function () {
+      return props.position;
+    }),
+    dangerouslyUseHTMLString: false,
+    positionStyle: computed(function () {
+      return api.getOffsetStyle(state);
+    }),
+    verticalProperty: computed(function () {
+      return api.getPositionSide(state);
+    }),
+    customClass: computed(function () {
+      return props.customClass;
+    })
+  });
+  Object.assign(api, {
+    state: state,
+    getZindex: getZindex,
+    getOffsetStyle: getOffsetStyle,
+    getPositionSide: getPositionSide,
+    close: close({
+      state: state,
+      props: props
+    }),
+    click: click({
+      emit: emit,
+      state: state
+    }),
+    clearTimer: clearTimer(state),
+    bindEvent: bindEvent({
+      api: api,
+      state: state
+    }),
+    unBindEvent: unBindEvent(api),
+    startTimer: startTimer({
+      api: api,
+      state: state
+    }),
+    watchClosed: watchClosed(state)
+  });
+  watch(function () {
+    return state.closed;
+  }, api.watchClosed, {
+    immediate: true
+  });
+  onMounted(api.bindEvent);
+  onBeforeUnmount(api.unBindEvent);
+  return api;
+};

package/numeric/index.js

@@ -0,0 +1,419 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { formatNumber, roundFixed } from '@opentiny/vue-renderless/common/decimal';
+import { getMiniDecimal, lessEquals, equalsDecimal } from '@opentiny/vue-renderless/common/bigInt';
+import { isNumber, isNull } from '@opentiny/vue-renderless/common/type';
+import { MOUSEDELTA } from '@opentiny/vue-renderless/common';
+import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
+export var initService = function initService(service) {
+  var _ref = service || {},
+    _ref$utils = _ref.utils,
+    utils = _ref$utils === void 0 ? {} : _ref$utils;
+  var noopFn = function noopFn() {
+    return null;
+  };
+  return {
+    getUnitPrecision: utils.getUnitPrecision || noopFn,
+    getNumberFormat: utils.getNumberFormat || noopFn
+  };
+};
+export var getDecimal = function getDecimal(props) {
+  return function (value) {
+    return getMiniDecimal(value, props.plugin);
+  };
+};
+export var watchValue = function watchValue(_ref2) {
+  var api = _ref2.api,
+    state = _ref2.state;
+  return function (value) {
+    if (value === state.currentValue) return;
+    api.setCurrentValue(value);
+  };
+};
+export var toPrecision = function toPrecision(state) {
+  return function (_ref3) {
+    var num = _ref3.num,
+      precision = _ref3.precision;
+    if (precision === undefined) {
+      precision = state.numPrecision;
+    }
+    return parseFloat(Math.round(num * Math.pow(10, precision)) / Math.pow(10, precision));
+  };
+};
+export var getPrecision = function getPrecision() {
+  return function (value) {
+    if (value === undefined) {
+      return 0;
+    }
+    var valueString = value.toString();
+    var dotPosition = valueString.indexOf('.');
+    var precision = 0;
+    if (dotPosition !== -1) {
+      precision = valueString.length - dotPosition - 1;
+    }
+    return precision;
+  };
+};
+export var internalIncrease = function internalIncrease(_ref4) {
+  var api = _ref4.api,
+    state = _ref4.state;
+  return function (_ref5) {
+    var val = _ref5.val,
+      step = _ref5.step;
+    var decimal = api.getDecimal(val);
+    if (decimal.isNaN() && val !== undefined) {
+      return state.currentValue;
+    }
+    return decimal.add(step).toString();
+  };
+};
+export var internalDecrease = function internalDecrease(_ref6) {
+  var api = _ref6.api,
+    state = _ref6.state;
+  return function (_ref7) {
+    var val = _ref7.val,
+      step = _ref7.step;
+    var decimal = api.getDecimal(val);
+    if (decimal.isNaN() && val !== undefined) {
+      return state.currentValue;
+    }
+    return decimal.add("-".concat(step)).toString();
+  };
+};
+export var increase = function increase(_ref8) {
+  var api = _ref8.api,
+    props = _ref8.props,
+    state = _ref8.state;
+  return function () {
+    if (state.inputDisabled || state.maxDisabled) {
+      return;
+    }
+    var value = props.modelValue || 0;
+    var newVal = api.internalIncrease({
+      val: value,
+      step: props.step
+    });
+    if (!props.circulate || !isFinite(props.max) || !isFinite(props.min)) {
+      api.setCurrentValue(newVal);
+      return;
+    }
+    if (!lessEquals(newVal, props.max) || lessEquals(newVal, props.min)) {
+      newVal = props.min;
+    }
+    api.setCurrentValue(newVal);
+  };
+};
+export var decrease = function decrease(_ref9) {
+  var api = _ref9.api,
+    props = _ref9.props,
+    state = _ref9.state;
+  return function () {
+    if (state.inputDisabled || state.minDisabled) {
+      return;
+    }
+    var value = props.modelValue || 0;
+    var newVal = api.internalDecrease({
+      val: value,
+      step: props.step
+    });
+    if (!props.circulate || !isFinite(props.max) || !isFinite(props.min)) {
+      api.setCurrentValue(newVal);
+      return;
+    }
+    if (!lessEquals(props.min, newVal) || lessEquals(props.max, newVal)) {
+      newVal = props.max;
+    }
+    api.setCurrentValue(newVal);
+  };
+};
+export var handleBlur = function handleBlur(_ref10) {
+  var constants = _ref10.constants,
+    dispatch = _ref10.dispatch,
+    emit = _ref10.emit,
+    props = _ref10.props,
+    state = _ref10.state,
+    api = _ref10.api;
+  return function (event) {
+    state.inputStatus = false;
+    api.setCurrentValue(event.target.value);
+    emit('blur', event);
+    if (props.validateEvent) {
+      dispatch(constants.COMPONENT_NAME, constants.EVENT_NAME.blur, [state.displayValue]);
+    }
+  };
+};
+export var handleFocus = function handleFocus(_ref11) {
+  var emit = _ref11.emit,
+    state = _ref11.state,
+    props = _ref11.props,
+    api = _ref11.api;
+  return function (event) {
+    state.inputStatus = true;
+    var currentValue = api.getDecimal(state.currentValue);
+    if (!currentValue.isNaN() && !isNull(state.currentValue)) {
+      var fractionLen = (currentValue.toString().split('.')[1] || '').length;
+      if (fractionLen < state.format.fraction && props.holdZero) {
+        state.currentValue = formatNumber(state.currentValue, {
+          fraction: state.format.fraction
+        });
+        state.userInput = state.currentValue;
+        state.lastInput = state.currentValue;
+      }
+    }
+    emit('focus', event);
+  };
+};
+export var focus = function focus(refs) {
+  return function () {
+    refs.input.focus();
+  };
+};
+var getEmitValue = function getEmitValue(args) {
+  var newVal = args.newVal,
+    emitValue = args.emitValue,
+    allowEmpty = args.allowEmpty,
+    defaultVal = args.defaultVal,
+    bigNew = args.bigNew,
+    oldVal = args.oldVal;
+  var max = args.max,
+    min = args.min,
+    api = args.api,
+    props = args.props,
+    format = args.format,
+    plugin = args.plugin,
+    stringMode = args.stringMode;
+  if (!newVal && newVal !== 0) {
+    emitValue = allowEmpty ? undefined : defaultVal;
+  } else if (bigNew.isNaN()) {
+    emitValue = oldVal;
+  } else {
+    if (isFinite(max) && lessEquals(max, newVal)) {
+      newVal = max;
+    }
+    if (isFinite(min) && lessEquals(newVal, min)) {
+      newVal = min;
+    }
+    emitValue = api.getDecimal(newVal).toString();
+    if (props.modelTruncation) {
+      emitValue = roundFixed(emitValue, format.fraction, format.rounding, plugin);
+    }
+    if (!props.holdZero) {
+      emitValue = api.getDecimal(emitValue).toString();
+    }
+    if (!stringMode) {
+      emitValue = emitValue * 1;
+    }
+  }
+  return {
+    newVal: newVal,
+    emitValue: emitValue
+  };
+};
+export var setCurrentValue = function setCurrentValue(_ref12) {
+  var api = _ref12.api,
+    constants = _ref12.constants,
+    dispatch = _ref12.dispatch,
+    emit = _ref12.emit,
+    props = _ref12.props,
+    state = _ref12.state;
+  return function (newVal) {
+    var max = props.max,
+      min = props.min,
+      allowEmpty = props.allowEmpty,
+      validateEvent = props.validateEvent,
+      stringMode = props.stringMode,
+      plugin = props.plugin;
+    var format = state.format;
+    var oldVal = state.currentValue;
+    var bigNew = api.getDecimal(newVal);
+    var defaultVal = isFinite(min) ? min : 0;
+    var emitValue = bigNew.toString();
+    if (equalsDecimal(state.currentValue, newVal)) {
+      state.userInput = state.currentValue;
+      return;
+    }
+    var args = {
+      newVal: newVal,
+      emitValue: emitValue,
+      allowEmpty: allowEmpty,
+      defaultVal: defaultVal,
+      bigNew: bigNew,
+      oldVal: oldVal
+    };
+    Object.assign(args, {
+      max: max,
+      min: min,
+      api: api,
+      props: props,
+      format: format,
+      plugin: plugin,
+      stringMode: stringMode
+    });
+    var ret = getEmitValue(args);
+    newVal = ret.newVal;
+    emitValue = ret.emitValue;
+    state.userInput = emitValue;
+    state.lastInput = emitValue;
+    if (emitValue !== oldVal) {
+      emit('update:modelValue', emitValue);
+      emit('change', emitValue, oldVal);
+      state.currentValue = emitValue;
+      state.userInput = emitValue;
+      if (validateEvent && oldVal === '') {
+        dispatch(constants.COMPONENT_NAME, constants.EVENT_NAME.blur, [state.currentValue]);
+      }
+      if (validateEvent) {
+        dispatch(constants.COMPONENT_NAME, constants.EVENT_NAME.change, [state.currentValue]);
+      }
+    }
+  };
+};
+export var handleInput = function handleInput(_ref13) {
+  var state = _ref13.state,
+    api = _ref13.api,
+    emit = _ref13.emit,
+    props = _ref13.props;
+  return function (event) {
+    var fraction = state.format.fraction;
+    var emitError = function emitError() {
+      if (state.pasting) {
+        emit('paste-error', event.target.value);
+      }
+    };
+    var value = event.target.value.replace(/^-+/, '-');
+    if (value !== '-' && api.getDecimal(value).isNaN()) {
+      emitError();
+      if (!(value === '' && props.allowEmpty)) {
+        value = state.lastInput;
+      }
+    } else {
+      value = value.split('.').map(function (a, i) {
+        if (i && a.length > fraction) {
+          emitError();
+        }
+        return i && state.strictInput && typeof fraction === 'number' ? a.substr(0, fraction) : a;
+      }).join('.');
+    }
+    event.target.value = isNull(value) ? '' : value;
+    state.lastInput = value;
+    state.userInput = value;
+  };
+};
+export var handleInputChange = function handleInputChange(_ref14) {
+  var api = _ref14.api;
+  return function (event) {
+    var value = event.target.value;
+    api.setCurrentValue(value === '-' ? 0 : value);
+  };
+};
+export var select = function select(refs) {
+  return function () {
+    return refs.input.select();
+  };
+};
+export var mounted = function mounted(_ref15) {
+  var constants = _ref15.constants,
+    parent = _ref15.parent,
+    props = _ref15.props,
+    state = _ref15.state;
+  return function () {
+    var innerInput = parent.$el.querySelector('input');
+    innerInput.setAttribute(constants.KEY, constants.VALUE);
+    innerInput.setAttribute(constants.MAX, props.max);
+    innerInput.setAttribute(constants.MIN, props.min);
+    innerInput.setAttribute(constants.VALUENOW, state.currentValue);
+    innerInput.setAttribute(constants.DISABLED, state.inputDisabled);
+    state.onPase = function () {
+      state.pasting = true;
+      setTimeout(function () {
+        return state.pasting = false;
+      });
+    };
+    on(innerInput, 'paste', state.onPase);
+  };
+};
+export var unmounted = function unmounted(_ref16) {
+  var parent = _ref16.parent,
+    state = _ref16.state;
+  return function () {
+    var innerInput = parent.$el.querySelector('input');
+    off(innerInput, 'paste', state.onPase);
+  };
+};
+export var updated = function updated(_ref17) {
+  var constants = _ref17.constants,
+    parent = _ref17.parent,
+    state = _ref17.state;
+  return function () {
+    var innerInput = parent.$el.querySelector('input');
+    innerInput && innerInput.setAttribute(constants.VALUENOW, state.currentValue);
+  };
+};
+export var displayValue = function displayValue(_ref18) {
+  var props = _ref18.props,
+    state = _ref18.state;
+  return function () {
+    var currentValue = state.currentValue,
+      inputStatus = state.inputStatus,
+      userInput = state.userInput;
+    if (inputStatus) {
+      return userInput;
+    }
+    if (props.allowEmpty && currentValue === '') {
+      return '';
+    }
+    return formatNumber(currentValue, state.format);
+  };
+};
+export var getNumPecision = function getNumPecision(_ref19) {
+  var api = _ref19.api,
+    props = _ref19.props;
+  return function () {
+    var stepPrecision = api.getPrecision(props.step);
+    if (props.precision !== undefined) {
+      return props.precision;
+    } else {
+      return Math.max(api.getPrecision(props.modelValue), stepPrecision);
+    }
+  };
+};
+export var mouseEvent = function mouseEvent(_ref20) {
+  var api = _ref20.api,
+    props = _ref20.props,
+    state = _ref20.state;
+  return function (event) {
+    if (props.mouseWheel && state.inputStatus) {
+      var delta = 0;
+      if (event.wheelDelta) {
+        delta = event.wheelDelta / MOUSEDELTA;
+      }
+      delta > 0 ? api.increase() : api.decrease();
+      return false;
+    }
+  };
+};
+export var getUnitPrecision = function getUnitPrecision(_ref21) {
+  var service = _ref21.service,
+    props = _ref21.props;
+  var fraction, rounding;
+  var _props$format = props.format,
+    format = _props$format === void 0 ? {} : _props$format,
+    precision = props.precision,
+    unit = props.unit;
+  var defaultFmt = {
+    groupSeparator: '',
+    decimalSeparator: '.',
+    zeroize: props.holdZero
+  };
+  var getUnitPrecision = service.getUnitPrecision,
+    getNumberFormat = service.getNumberFormat;
+  var serFra = getUnitPrecision(unit) || {};
+  var serFmt = getNumberFormat() || {};
+  fraction = isNumber(precision) ? precision : isNumber(format.fraction) ? format.fraction : serFra.fraction;
+  rounding = isNumber(format.rounding) ? format.rounding : serFra.rounding;
+  return _objectSpread(_objectSpread(_objectSpread({}, defaultFmt), {}, {
+    fraction: fraction,
+    rounding: rounding
+  }, serFmt), format);
+};