@vunk/form 2.2.3 → 2.3.1

package/components/api-tables-select/index.cjs

@@ -0,0 +1,468 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tablesSelect = require('@vunk/form/components/tables-select');
+var object = require('@vunk/shared/object');
+var vue = require('vue');
+var form = require('@vunk/form');
+var core = require('@vunk/core');
+var isObject = require('../isObject.cjs');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const tablesSelectProps = object.pickObject(tablesSelect._VkfTablesSelectCtx.props, {
+  excludes: [
+    "currentPage",
+    "pageSize",
+    "total",
+    "data",
+    "start"
+  ]
+});
+const props = {
+  ...tablesSelectProps,
+  /**
+   * @description 读取数据的api
+   */
+  readApi: {
+    type: Function,
+    default: () => ({ rows: [], total: 0 })
+  },
+  /**
+   * @description 获取完整数据
+   * @default props.rApi({ ids: ids.join(',') })
+   */
+  getRows: {
+    type: Function,
+    default: void 0
+  },
+  /**
+   * query表单配置
+   */
+  queryItems: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * query表单是否继承父级模板
+   */
+  inheritTemplates: {
+    type: Boolean,
+    default: false
+  }
+};
+({
+  ...tablesSelect._VkfTablesSelectCtx.emits
+});
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObject.isObjectLike(value) && isObject.baseGetTag(value) == symbolTag);
+}
+
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+function trimmedEndIndex(string) {
+  var index = string.length;
+
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+
+/**
+ * The base implementation of `_.trim`.
+ *
+ * @private
+ * @param {string} string The string to trim.
+ * @returns {string} Returns the trimmed string.
+ */
+function baseTrim(string) {
+  return string
+    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+    : string;
+}
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject.isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject.isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now = function() {
+  return isObject.root.Date.now();
+};
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+function debounce(func, wait, options) {
+  var lastArgs,
+      lastThis,
+      maxWait,
+      result,
+      timerId,
+      lastCallTime,
+      lastInvokeTime = 0,
+      leading = false,
+      maxing = false,
+      trailing = true;
+
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject.isObject(options)) {
+    leading = !!options.leading;
+    maxing = 'maxWait' in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+
+  function invokeFunc(time) {
+    var args = lastArgs,
+        thisArg = lastThis;
+
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+
+  function leadingEdge(time) {
+    // Reset any `maxWait` timer.
+    lastInvokeTime = time;
+    // Start the timer for the trailing edge.
+    timerId = setTimeout(timerExpired, wait);
+    // Invoke the leading edge.
+    return leading ? invokeFunc(time) : result;
+  }
+
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime,
+        timeWaiting = wait - timeSinceLastCall;
+
+    return maxing
+      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+      : timeWaiting;
+  }
+
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime,
+        timeSinceLastInvoke = time - lastInvokeTime;
+
+    // Either this is the first call, activity has stopped and we're at the
+    // trailing edge, the system time has gone backwards and we're treating
+    // it as the trailing edge, or we've hit the `maxWait` limit.
+    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+  }
+
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    // Restart the timer.
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+
+  function trailingEdge(time) {
+    timerId = undefined;
+
+    // Only invoke if we have `lastArgs` which means `func` has been
+    // debounced at least once.
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(now());
+  }
+
+  function debounced() {
+    var time = now(),
+        isInvoking = shouldInvoke(time);
+
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        // Handle invocations in a tight loop.
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfApiTablesSelect",
+  components: {
+    VkfTablesSelect: tablesSelect.VkfTablesSelect,
+    VkfForm: form.VkfForm
+  },
+  props,
+  setup(props2, { emit }) {
+    const debounceRead = debounce(read, 300);
+    const coreProps = tablesSelect._VkfTablesSelectCtx.createBindProps(props2, ["getRows"]);
+    const coreEmits = tablesSelect._VkfTablesSelectCtx.createOnEmits(emit);
+    const queryData = vue.ref({});
+    const tableState = vue.reactive({
+      data: [],
+      total: 0
+    });
+    const pagination = vue.ref({
+      pageSize: 10,
+      start: 0
+    });
+    vue.watch(pagination, debounceRead, { deep: true, immediate: true });
+    vue.watch(queryData, debounceRead, { deep: true });
+    async function read() {
+      const res = await props2.readApi(queryData.value, {
+        ...pagination.value,
+        currentPage: pagination.value.start / pagination.value.pageSize + 1
+      });
+      tableState.data = res.rows;
+      tableState.total = res.total;
+    }
+    const defaultGetRows = async (ids) => {
+      const { rows } = await props2.readApi({
+        ids: ids.join(",")
+      });
+      return rows;
+    };
+    return {
+      pagination,
+      tableState,
+      setData: core.setData,
+      queryData,
+      coreProps,
+      coreEmits,
+      defaultGetRows
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfForm = vue.resolveComponent("VkfForm");
+  const _component_VkfTablesSelect = vue.resolveComponent("VkfTablesSelect");
+  return vue.openBlock(), vue.createBlock(_component_VkfTablesSelect, vue.mergeProps({
+    start: _ctx.pagination.start,
+    "onUpdate:start": _cache[1] || (_cache[1] = ($event) => _ctx.pagination.start = $event),
+    "page-size": _ctx.pagination.pageSize,
+    "onUpdate:pageSize": _cache[2] || (_cache[2] = ($event) => _ctx.pagination.pageSize = $event),
+    data: _ctx.tableState.data,
+    total: _ctx.tableState.total,
+    "get-rows": _ctx.getRows || _ctx.defaultGetRows
+  }, _ctx.coreProps, vue.toHandlers(_ctx.coreEmits)), {
+    dialog: vue.withCtx(() => [
+      vue.createVNode(_component_VkfForm, {
+        "form-items": _ctx.queryItems,
+        inline: true,
+        data: _ctx.queryData,
+        "inherit-templates": _ctx.inheritTemplates,
+        onSetData: _cache[0] || (_cache[0] = ($event) => _ctx.setData(_ctx.queryData, $event))
+      }, null, 8, ["form-items", "data", "inherit-templates"]),
+      vue.renderSlot(_ctx.$slots, "dialog")
+    ]),
+    _: 3
+    /* FORWARDED */
+  }, 16, ["start", "page-size", "data", "total", "get-rows"]);
+}
+var VkfApiTablesSelect = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/api-tables-select/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfApiTablesSelect.install = (app) => {
+  app.component(VkfApiTablesSelect.name || "VkfApiTablesSelect", VkfApiTablesSelect);
+};
+
+exports.VkfApiTablesSelect = VkfApiTablesSelect;
+exports.__VkfApiTablesSelect = types;
+exports.default = VkfApiTablesSelect;

package/components/api-tables-select/index.d.ts

@@ -0,0 +1,4 @@
+import VkfApiTablesSelect from './src/index.vue';
+export * as __VkfApiTablesSelect from './src/types';
+export { VkfApiTablesSelect, };
+export default VkfApiTablesSelect;