vue-admin-core/lib/formily/search-form/src/index.js

A Component Library for Vue 3

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var reactiveVue = require('@formily/reactive-vue');
require('../../form-grid/index.js');
var reactive = require('@formily/reactive');
var vue$1 = require('@formily/vue');
require('../../submit/index.js');
require('../../reset/index.js');
require('../../form-button-group/index.js');
var elementPlus = require('element-plus');
require('../../form/index.js');
require('../../__builtins__/index.js');
var runtime = require('element-plus/es/utils/vue/props/runtime');
var index = require('../../form/src/index.js');
var index$1 = require('../../form-grid/src/index.js');
var index$2 = require('../../submit/src/index.js');
var index$3 = require('../../reset/src/index.js');
var index$4 = require('../../form-button-group/src/index.js');
var utils = require('../../__builtins__/shared/utils.js');

function _isSlot(s) {
  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
}
const searchFormProps = {
  ...index.formProps,
  ...index$1.formGridProps,
  ...runtime.buildProps({
    /**
     * 查询回调方法
     */
    onSubmit: {
      type: Function
    },
    /**
     * 重置回调方法
     */
    onReset: {
      type: Function
    }
  })
};
const useCollapseGrid = (options) => {
  var _a;
  const maxRows = (_a = options == null ? void 0 : options.maxRows) != null ? _a : 1;
  const grid = index$1.FormGrid.createFormGrid({
    maxColumns: [1, 2, 4],
    minColumns: [1, 2, 4],
    maxRows,
    ...options,
    shouldVisible: (node, grid2) => {
      if (node.index === grid2.childSize - 1)
        return true;
      if (grid2.maxRows === Infinity)
        return true;
      return (node.shadowRow || 0) < maxRows + 1;
    }
  });
  const expanded = vue.ref(false);
  const type = vue.ref("");
  const takeType = (realRows, computeRows) => {
    if (realRows < maxRows + 1)
      return "incomplete-wrap";
    if (computeRows > maxRows)
      return "collapsible";
    return "complete-wrap";
  };
  const dispose = reactive.autorun(() => {
    expanded.value = grid.maxRows === Infinity;
    const realRows = grid.shadowRows;
    const computeRows = grid.fullnessLastColumn ? grid.shadowRows - 1 : grid.shadowRows;
    type.value = takeType(realRows, computeRows);
  });
  vue.onUnmounted(dispose);
  const toggle = () => {
    if (grid.maxRows === Infinity) {
      grid.maxRows = maxRows;
    } else {
      grid.maxRows = Infinity;
    }
  };
  return {
    grid,
    expanded,
    toggle,
    type
  };
};
const SearchFormInner = reactiveVue.observer(vue.defineComponent({
  name: "FSearchForm",
  props: searchFormProps,
  setup(props, {
    slots
  }) {
    const {
      onSubmit,
      onReset,
      ...reset
    } = props;
    const {
      grid,
      expanded,
      toggle,
      type
    } = useCollapseGrid(reset);
    const renderActions = () => {
      if (slots.actions)
        return slots.actions();
      return vue.createVNode(vue$1.FragmentComponent, null, {
        default: () => [vue.createVNode(index$2.Submit, {
          "onSubmit": onSubmit
        }, {
          default: () => [vue.createTextVNode("\u67E5\u8BE2")]
        }), vue.createVNode(index$3.Reset, {
          "onClick": onReset
        }, {
          default: () => [vue.createTextVNode("\u91CD\u7F6E")]
        })]
      });
    };
    const renderButtonGroup = () => {
      let _slot2;
      if (type.value === "incomplete-wrap") {
        let _slot;
        return vue.createVNode(index$4.FormButtonGroup, {
          "align": "left"
        }, _isSlot(_slot = renderActions()) ? _slot : {
          default: () => [_slot]
        });
      }
      if (type.value === "collapsible") {
        return vue.createVNode(index$4.FormButtonGroup, {
          "align": "right"
        }, {
          default: () => [vue.createVNode(vue$1.FragmentComponent, null, {
            default: () => [vue.createVNode(elementPlus.ElButton, {
              "type": "primary",
              "onClick": toggle,
              "text": true
            }, {
              default: () => [expanded.value ? "\u6536\u8D77" : "\u5C55\u5F00"]
            }), renderActions()]
          })]
        });
      }
      return vue.createVNode(index$4.FormButtonGroup, {
        "align": "right",
        "style": {
          display: "flex",
          width: "100%"
        }
      }, _isSlot(_slot2 = renderActions()) ? _slot2 : {
        default: () => [_slot2]
      });
    };
    return () => {
      let _slot3;
      return (
        // @ts-ignore
        vue.createVNode(index.Form, vue.mergeProps(reset, {
          "feedbackLayout": "terse"
        }), {
          default: () => [vue.createVNode(index$1.FormGrid, {
            "grid": grid
          }, {
            default: () => [slots.default && slots.default(), vue.createVNode(index$1.FormGrid.GridColumn, {
              "gridSpan": -1
            }, _isSlot(_slot3 = renderButtonGroup()) ? _slot3 : {
              default: () => [_slot3]
            })]
          })]
        })
      );
    };
  }
}));
const SearchForm = utils.composeExport(SearchFormInner, {
  useCollapseGrid
});

exports.SearchForm = SearchForm;
exports.default = SearchForm;
exports.searchFormProps = searchFormProps;
//# sourceMappingURL=index.js.map