@vunk/form 1.1.85 → 1.2.0

package/composables/index.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+var vue = require('vue');
+
+const useSourceManager = (source, opts = {}) => {
+  if (!vue.isRef(source)) {
+    source = vue.ref(source);
+  }
+  const op = {
+    ...opts,
+    slotsChildren: ["default"]
+  };
+  opts.slotsChildren && op.slotsChildren.push(...opts.slotsChildren);
+  const manager = vue.computed(() => {
+    const keyRecord = {};
+    const propRecord = {};
+    const idRecord = {};
+    function intoData(list, k = []) {
+      list.forEach((item, index) => {
+        const currentK = [...k, index];
+        const managerInfo = {
+          source: item,
+          key: currentK,
+          nextKey: [...k, index + 1],
+          prop: item.prop,
+          id: item.id
+        };
+        keyRecord[currentK.join()] = managerInfo;
+        if (item.prop) {
+          propRecord[item.prop] = managerInfo;
+        }
+        if (item.id) {
+          idRecord[item.id] = managerInfo;
+        }
+        if (item.templateSlots) {
+          if (Array.isArray(item.templateSlots)) {
+            currentK.push("templateSlots");
+            intoData(item.templateSlots, currentK);
+          }
+          op.slotsChildren.forEach((filed) => {
+            if (Array.isArray(item.templateSlots[filed])) {
+              currentK.push("templateSlots", filed);
+              intoData(item.templateSlots[filed], currentK);
+            }
+          });
+        }
+      });
+    }
+    intoData(vue.unref(source));
+    return {
+      keyRecord,
+      propRecord,
+      idRecord
+    };
+  });
+  const getManagerInfoByProp = (prop) => {
+    return manager.value.propRecord[prop];
+  };
+  const getManagerInfoByKey = (key) => {
+    return manager.value.keyRecord[key.join()];
+  };
+  const getManagerInfoById = (id) => {
+    return manager.value.idRecord[id];
+  };
+  return [
+    source,
+    {
+      manager,
+      getManagerInfoByProp,
+      getManagerInfoByKey,
+      getManagerInfoById
+    }
+  ];
+};
+
+const useForm = () => {
+  return vue.inject("vkfFormVm", null);
+};
+const useComputedReadonly = (props) => {
+  const form = useForm();
+  const readonly = vue.computed(() => {
+    return props.readonly ?? form?.props.readonly ?? false;
+  });
+  return readonly;
+};
+
+exports.useComputedReadonly = useComputedReadonly;
+exports.useForm = useForm;
+exports.useSourceManager = useSourceManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vunk/form",
-  "version": "1.1.85",
+  "version": "1.2.0",
   "description": "",
   "main": "index.esm.js",
   "scripts": {
@@ -20,59 +20,73 @@
     },
     "./shared": {
       "import": "./shared/index.mjs",
-      "types": "./shared/index.d.ts"
+      "types": "./shared/index.d.ts",
+      "require": "./shared/index.cjs"
     },
     "./shared/upload": {
       "import": "./shared/upload/index.mjs",
-      "types": "./shared/upload/index.d.ts"
+      "types": "./shared/upload/index.d.ts",
+      "require": "./shared/upload/index.cjs"
     },
     "./shared/types": {
       "import": "./shared/types/index.mjs",
-      "types": "./shared/types/index.d.ts"
+      "types": "./shared/types/index.d.ts",
+      "require": "./shared/types/index.cjs"
     },
     "./shared/types/source-manager": {
       "import": "./shared/types/source-manager/index.mjs",
-      "types": "./shared/types/source-manager/index.d.ts"
+      "types": "./shared/types/source-manager/index.d.ts",
+      "require": "./shared/types/source-manager/index.cjs"
     },
     "./shared/types/source": {
       "import": "./shared/types/source/index.mjs",
-      "types": "./shared/types/source/index.d.ts"
+      "types": "./shared/types/source/index.d.ts",
+      "require": "./shared/types/source/index.cjs"
     },
     "./shared/types/form": {
       "import": "./shared/types/form/index.mjs",
-      "types": "./shared/types/form/index.d.ts"
+      "types": "./shared/types/form/index.d.ts",
+      "require": "./shared/types/form/index.cjs"
     },
     "./shared/rules": {
       "import": "./shared/rules/index.mjs",
-      "types": "./shared/rules/index.d.ts"
+      "types": "./shared/rules/index.d.ts",
+      "require": "./shared/rules/index.cjs"
     },
     "./shared/progress-it": {
       "import": "./shared/progress-it/index.mjs",
-      "types": "./shared/progress-it/index.d.ts"
+      "types": "./shared/progress-it/index.d.ts",
+      "require": "./shared/progress-it/index.cjs"
     },
     "./shared/infer-prop": {
       "import": "./shared/infer-prop/index.mjs",
-      "types": "./shared/infer-prop/index.d.ts"
+      "types": "./shared/infer-prop/index.d.ts",
+      "require": "./shared/infer-prop/index.cjs"
     },
     "./shared/helper": {
       "import": "./shared/helper/index.mjs",
-      "types": "./shared/helper/index.d.ts"
+      "types": "./shared/helper/index.d.ts",
+      "require": "./shared/helper/index.cjs"
     },
     "./shared/form": {
       "import": "./shared/form/index.mjs",
-      "types": "./shared/form/index.d.ts"
+      "types": "./shared/form/index.d.ts",
+      "require": "./shared/form/index.cjs"
     },
     "./shared/element-plus": {
       "import": "./shared/element-plus/index.mjs",
-      "types": "./shared/element-plus/index.d.ts"
+      "types": "./shared/element-plus/index.d.ts",
+      "require": "./shared/element-plus/index.cjs"
     },
     "./shared/const": {
       "import": "./shared/const/index.mjs",
-      "types": "./shared/const/index.d.ts"
+      "types": "./shared/const/index.d.ts",
+      "require": "./shared/const/index.cjs"
     },
     "./composables": {
       "import": "./composables/index.mjs",
-      "types": "./composables/index.d.ts"
+      "types": "./composables/index.d.ts",
+      "require": "./composables/index.cjs"
     },
     "./components": {
       "import": "./components/index.mjs",

package/shared/const/index.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const CORE_FORM_TEMPLATE_OPTIONS = [
+  {
+    value: "VkfInput",
+    label: "\u8F93\u5165\u6846"
+  },
+  {
+    value: "VkfSelect",
+    label: "\u4E0B\u62C9\u6846"
+  },
+  {
+    value: "VkfCheckbox",
+    label: "\u591A\u9009\u6846"
+  },
+  {
+    value: "VkfRadio",
+    label: "\u5355\u9009\u6846"
+  },
+  {
+    value: "VkfDatePicker",
+    label: "\u65E5\u671F\u9009\u62E9\u5668"
+  },
+  {
+    value: "VkfInputNumber",
+    label: "\u6570\u5B57\u8F93\u5165\u6846"
+  },
+  {
+    value: "VkfSwitch",
+    label: "\u5F00\u5173"
+  },
+  {
+    value: "VkfSlider",
+    label: "\u6ED1\u5757"
+  },
+  {
+    value: "VkfInputLink",
+    label: "\u94FE\u63A5\u8F93\u5165\u6846"
+  },
+  {
+    value: "VkfEsriInputGeojson",
+    label: "\u5730\u4FE1\u8F93\u5165\u6846"
+  },
+  {
+    value: "VkfCascader",
+    label: "\u7EA7\u8054\u9009\u62E9\u5668"
+  },
+  {
+    value: "VkfUpload",
+    label: "\u4E0A\u4F20"
+  }
+];
+const CORE_FORM_TEMPLATE_REFLECT = CORE_FORM_TEMPLATE_OPTIONS.reduce((acc, cur) => {
+  acc[cur.value] = cur;
+  return acc;
+}, {});
+
+exports.CORE_FORM_TEMPLATE_OPTIONS = CORE_FORM_TEMPLATE_OPTIONS;
+exports.CORE_FORM_TEMPLATE_REFLECT = CORE_FORM_TEMPLATE_REFLECT;

package/shared/element-plus/index.cjs

@@ -0,0 +1,317 @@
+'use strict';
+
+var elementPlus = require('element-plus');
+var utilsVue = require('@vunk/core/shared/utils-vue');
+var vue = require('vue');
+
+/*! Element Plus Icons Vue v2.3.1 */
+
+var arrow_down_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.defineComponent({
+  name: "ArrowDown",
+  __name: "arrow-down",
+  setup(__props) {
+    return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 1024 1024"
+    }, [
+      vue.createElementVNode("path", {
+        fill: "currentColor",
+        d: "M831.872 340.864 512 652.672 192.128 340.864a30.592 30.592 0 0 0-42.752 0 29.12 29.12 0 0 0 0 41.6L489.664 714.24a32 32 0 0 0 44.672 0l340.288-331.712a29.12 29.12 0 0 0 0-41.728 30.592 30.592 0 0 0-42.752 0z"
+      })
+    ]));
+  }
+});
+
+// src/components/arrow-down.vue
+var arrow_down_default = arrow_down_vue_vue_type_script_setup_true_lang_default;
+var circle_close_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ vue.defineComponent({
+  name: "CircleClose",
+  __name: "circle-close",
+  setup(__props) {
+    return (_ctx, _cache) => (vue.openBlock(), vue.createElementBlock("svg", {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 1024 1024"
+    }, [
+      vue.createElementVNode("path", {
+        fill: "currentColor",
+        d: "m466.752 512-90.496-90.496a32 32 0 0 1 45.248-45.248L512 466.752l90.496-90.496a32 32 0 1 1 45.248 45.248L557.248 512l90.496 90.496a32 32 0 1 1-45.248 45.248L512 557.248l-90.496 90.496a32 32 0 0 1-45.248-45.248z"
+      }),
+      vue.createElementVNode("path", {
+        fill: "currentColor",
+        d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768m0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896"
+      })
+    ]));
+  }
+});
+
+// src/components/circle-close.vue
+var circle_close_default = circle_close_vue_vue_type_script_setup_true_lang_default;
+
+const datePickerProps = {
+  ...elementPlus.timePickerDefaultProps,
+  type: {
+    type: String,
+    default: "date"
+  }
+};
+const datePickerEmits = {
+  "update:modelValue": null,
+  "change": null,
+  "focus": null,
+  "blur": null,
+  "calendar-change": null,
+  "panel-change": null,
+  "visible-change": null,
+  "keydown": null
+};
+const selectProps = {
+  name: String,
+  id: String,
+  modelValue: {
+    type: [Array, String, Number, Boolean, Object],
+    default: void 0
+  },
+  autocomplete: {
+    type: String,
+    default: "off"
+  },
+  automaticDropdown: Boolean,
+  size: {
+    type: String
+  },
+  effect: {
+    type: String,
+    default: "light"
+  },
+  disabled: Boolean,
+  clearable: Boolean,
+  filterable: Boolean,
+  allowCreate: Boolean,
+  loading: Boolean,
+  popperClass: {
+    type: String,
+    default: ""
+  },
+  remote: Boolean,
+  loadingText: String,
+  noMatchText: String,
+  noDataText: String,
+  remoteMethod: Function,
+  filterMethod: Function,
+  multiple: Boolean,
+  multipleLimit: {
+    type: Number,
+    default: 0
+  },
+  placeholder: {
+    type: String
+  },
+  defaultFirstOption: Boolean,
+  reserveKeyword: {
+    type: Boolean,
+    default: true
+  },
+  valueKey: {
+    type: String,
+    default: "value"
+  },
+  collapseTags: Boolean,
+  collapseTagsTooltip: {
+    type: Boolean,
+    default: false
+  },
+  teleported: elementPlus.useTooltipContentProps.teleported,
+  persistent: {
+    type: Boolean,
+    default: true
+  },
+  clearIcon: {
+    type: [String, Object],
+    default: circle_close_default
+  },
+  fitInputWidth: {
+    type: Boolean,
+    default: false
+  },
+  suffixIcon: {
+    type: [String, Object],
+    default: arrow_down_default
+  },
+  // eslint-disable-next-line vue/require-prop-types
+  tagType: { ...elementPlus.tagProps.type, default: "info" }
+};
+const selectEmits = {
+  "update:modelValue": null,
+  "change": null,
+  "remove-tag": null,
+  "clear": null,
+  "visible-change": null,
+  "focus": null,
+  "blur": null
+};
+
+const createInputBindProps = utilsVue.bindPropsFactory(elementPlus.inputProps);
+const createInputOnEmits = utilsVue.onEmitsFactory(elementPlus.inputEmits);
+const createFormBindProps = utilsVue.bindPropsFactory(elementPlus.formProps);
+const createFormOnEmits = utilsVue.onEmitsFactory(elementPlus.formEmits);
+const createFormItemBindProps = utilsVue.bindPropsFactory(elementPlus.formItemProps);
+const createSwitchBindProps = utilsVue.bindPropsFactory(elementPlus.switchProps);
+const createSwitchOnEmits = utilsVue.onEmitsFactory(elementPlus.switchEmits);
+const createSelectBindProps = utilsVue.bindPropsFactory(selectProps);
+const createSelectOnEmits = utilsVue.onEmitsFactory(selectEmits);
+const createDatePickerBindProps = utilsVue.bindPropsFactory(datePickerProps);
+const createDatePickerOnEmits = utilsVue.onEmitsFactory(datePickerEmits);
+const createInputNumberBindProps = utilsVue.bindPropsFactory(elementPlus.inputNumberProps);
+const createInputNumberOnEmits = utilsVue.onEmitsFactory(elementPlus.inputNumberEmits);
+const createRadioGroupBindProps = utilsVue.bindPropsFactory(elementPlus.radioGroupProps);
+const createRadioGroupOnEmits = utilsVue.onEmitsFactory(elementPlus.radioGroupEmits);
+const createCheckboxGroupBindProps = utilsVue.bindPropsFactory(elementPlus.checkboxGroupProps);
+const createCheckboxGroupOnEmits = utilsVue.onEmitsFactory(elementPlus.checkboxGroupEmits);
+const createUploadBindProps = utilsVue.bindPropsFactory(elementPlus.uploadProps);
+const createColorPickerBindProps = utilsVue.bindPropsFactory(elementPlus.colorPickerProps);
+const createColorPickerOnEmits = utilsVue.onEmitsFactory(elementPlus.colorPickerEmits);
+const createButtonBindProps = utilsVue.bindPropsFactory(elementPlus.buttonProps);
+const createButtonOnEmits = utilsVue.onEmitsFactory(elementPlus.buttonEmits);
+const createCascaderBindProps = utilsVue.bindPropsFactory(elementPlus.cascaderProps);
+const createCascaderOnEmits = utilsVue.onEmitsFactory(elementPlus.cascaderEmits);
+const createSliderBindProps = utilsVue.bindPropsFactory(elementPlus.sliderProps);
+const createSliderOnEmits = utilsVue.onEmitsFactory(elementPlus.sliderEmits);
+
+const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+const validateAndParse = (version) => {
+    if (typeof version !== 'string') {
+        throw new TypeError('Invalid argument expected string');
+    }
+    const match = version.match(semver);
+    if (!match) {
+        throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+    }
+    match.shift();
+    return match;
+};
+const isWildcard = (s) => s === '*' || s === 'x' || s === 'X';
+const tryParse = (v) => {
+    const n = parseInt(v, 10);
+    return isNaN(n) ? v : n;
+};
+const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+const compareStrings = (a, b) => {
+    if (isWildcard(a) || isWildcard(b))
+        return 0;
+    const [ap, bp] = forceType(tryParse(a), tryParse(b));
+    if (ap > bp)
+        return 1;
+    if (ap < bp)
+        return -1;
+    return 0;
+};
+const compareSegments = (a, b) => {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const r = compareStrings(a[i] || '0', b[i] || '0');
+        if (r !== 0)
+            return r;
+    }
+    return 0;
+};
+
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+const compareVersions = (v1, v2) => {
+    // validate input and split into segments
+    const n1 = validateAndParse(v1);
+    const n2 = validateAndParse(v2);
+    // pop off the patch
+    const p1 = n1.pop();
+    const p2 = n2.pop();
+    // validate numbers
+    const r = compareSegments(n1, n2);
+    if (r !== 0)
+        return r;
+    // validate pre-release
+    if (p1 && p2) {
+        return compareSegments(p1.split('.'), p2.split('.'));
+    }
+    else if (p1 || p2) {
+        return p1 ? -1 : 1;
+    }
+    return 0;
+};
+
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+const compare = (v1, v2, operator) => {
+    // validate input operator
+    assertValidOperator(operator);
+    // since result of compareVersions can only be -1 or 0 or 1
+    // a simple map can be used to replace switch
+    const res = compareVersions(v1, v2);
+    return operatorResMap[operator].includes(res);
+};
+const operatorResMap = {
+    '>': [1],
+    '>=': [0, 1],
+    '=': [0],
+    '<=': [-1, 0],
+    '<': [-1],
+    '!=': [-1, 1],
+};
+const allowedOperators = Object.keys(operatorResMap);
+const assertValidOperator = (op) => {
+    if (allowedOperators.indexOf(op) === -1) {
+        throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);
+    }
+};
+
+const isGte2_6_0 = compare(elementPlus.version, "2.6.0", ">=");
+
+exports.createButtonBindProps = createButtonBindProps;
+exports.createButtonOnEmits = createButtonOnEmits;
+exports.createCascaderBindProps = createCascaderBindProps;
+exports.createCascaderOnEmits = createCascaderOnEmits;
+exports.createCheckboxGroupBindProps = createCheckboxGroupBindProps;
+exports.createCheckboxGroupOnEmits = createCheckboxGroupOnEmits;
+exports.createColorPickerBindProps = createColorPickerBindProps;
+exports.createColorPickerOnEmits = createColorPickerOnEmits;
+exports.createDatePickerBindProps = createDatePickerBindProps;
+exports.createDatePickerOnEmits = createDatePickerOnEmits;
+exports.createFormBindProps = createFormBindProps;
+exports.createFormItemBindProps = createFormItemBindProps;
+exports.createFormOnEmits = createFormOnEmits;
+exports.createInputBindProps = createInputBindProps;
+exports.createInputNumberBindProps = createInputNumberBindProps;
+exports.createInputNumberOnEmits = createInputNumberOnEmits;
+exports.createInputOnEmits = createInputOnEmits;
+exports.createRadioGroupBindProps = createRadioGroupBindProps;
+exports.createRadioGroupOnEmits = createRadioGroupOnEmits;
+exports.createSelectBindProps = createSelectBindProps;
+exports.createSelectOnEmits = createSelectOnEmits;
+exports.createSliderBindProps = createSliderBindProps;
+exports.createSliderOnEmits = createSliderOnEmits;
+exports.createSwitchBindProps = createSwitchBindProps;
+exports.createSwitchOnEmits = createSwitchOnEmits;
+exports.createUploadBindProps = createUploadBindProps;
+exports.datePickerEmits = datePickerEmits;
+exports.datePickerProps = datePickerProps;
+exports.isGte2_6_0 = isGte2_6_0;
+exports.selectEmits = selectEmits;
+exports.selectProps = selectProps;

package/shared/form/index.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var elementPlus = require('element-plus');
+
+const validateCatch = (err, init = {}) => {
+  let msg = "";
+  msg += init.prefix || "";
+  for (const key in err) {
+    err[key].forEach((v) => {
+      msg += v.message + ";";
+    });
+  }
+  msg += init.suffix || "";
+  elementPlus.ElMessage({
+    type: "warning",
+    message: msg
+  });
+};
+const genTemplateIfFunc = (templateIfRaw) => {
+  if (typeof templateIfRaw === "boolean") {
+    const flag = templateIfRaw;
+    return () => flag;
+  } else if (typeof templateIfRaw === "string") {
+    const templateIf = new Function("data", templateIfRaw);
+    return templateIf;
+  } else if (typeof templateIfRaw === "function") {
+    return templateIfRaw;
+  }
+  return () => true;
+};
+
+exports.genTemplateIfFunc = genTemplateIfFunc;
+exports.validateCatch = validateCatch;

package/shared/helper/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const createDefaultSlots = (o) => {
+  return {
+    default: Array.isArray(o) ? o : [
+      o
+    ]
+  };
+};
+
+exports.createDefaultSlots = createDefaultSlots;

package/shared/index.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var index = require('./const/index.cjs');
+
+
+
+exports.CORE_FORM_TEMPLATE_OPTIONS = index.CORE_FORM_TEMPLATE_OPTIONS;
+exports.CORE_FORM_TEMPLATE_REFLECT = index.CORE_FORM_TEMPLATE_REFLECT;

package/shared/infer-prop/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const inferString = (item) => ({
+  prop: item.prop,
+  type: "String"
+});
+const inferBoolean = (item) => ({
+  prop: item.prop,
+  type: "Boolean"
+});
+const inferNumber = (item) => {
+  const info = {
+    prop: item.prop,
+    type: "Number"
+  };
+  if (item.precision) {
+    info.precision = item.precision;
+  }
+  return info;
+};
+const inferDate = (item) => ({
+  prop: item.prop,
+  type: "Date"
+});
+const propInfoAction = {
+  VkfSelect: inferString,
+  VkfRadio: inferString,
+  VkfCheckbox: inferString,
+  VkfColorPicker: inferString,
+  VkfInputNumber: inferNumber,
+  VkfSwitch: inferBoolean,
+  VkfUpload: inferString,
+  VkfDatePicker: inferDate
+};
+
+exports.propInfoAction = propInfoAction;

package/shared/progress-it/index.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+const ifElse = (fn1, fn2, fn3) => (x) => fn1(x) ? fn2(x) : fn3(x);
+const progress = (effect, option) => (state) => {
+  const $data = {
+    interval: 100,
+    speed: 0.01,
+    ...option,
+    percent: 0,
+    timeLine: 0,
+    timer: void 0
+  };
+  const $stateInitFlow = ($data2) => ifElse(
+    (state2) => Boolean(state2),
+    (state2) => effect(1, state2),
+    (state2) => setInterval(() => {
+      $data2.timeLine++;
+      $data2.percent = state2 ? 1 : (-1 / ($data2.speed * $data2.timeLine + 1) + 1) * 1;
+      effect($data2.percent, state2);
+    }, $data2.interval)
+  );
+  $data.timer = $stateInitFlow($data)(state);
+  const setter = (newState) => {
+    if (typeof newState !== "boolean") {
+      $data.timer && clearInterval($data.timer);
+      $data.percent = 1;
+      effect($data.percent, "fail");
+      return setter;
+    }
+    if (newState) {
+      $data.timer && clearInterval($data.timer);
+      $data.percent = 1;
+      effect($data.percent, newState);
+    }
+    return setter;
+  };
+  return setter;
+};
+
+module.exports = progress;