ivue-material-plus/dist/unplugin-vue-components/lib/components/ivue-table/config.js

A high quality UI components Library with Vue.js

'use strict';

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

var vue = require('vue');
var shared = require('@vue/shared');
var index$1 = require('../ivue-checkbox/index2.js');
var index = require('../ivue-icon/index2.js');
var loading = require('./loading.js');
var objects = require('../../utils/objects.js');

const defaultClassNames = {
  selection: "ivue-table-column--selection",
  expand: "ivue-table--expand-column"
};
const cellStyles = {
  default: {
    order: ""
  },
  selection: {
    width: 48,
    minWidth: 48,
    columnWidth: 48,
    order: ""
  },
  expand: {
    width: 48,
    minWidth: 48,
    columnWidth: 48,
    order: ""
  },
  index: {
    width: 48,
    minWidth: 48,
    columnWidth: 48,
    order: ""
  }
};
function mergeOptions(defaults, config) {
  const options = {};
  let key;
  for (key in defaults) {
    options[key] = defaults[key];
  }
  for (key in config) {
    if (shared.hasOwn(config, key)) {
      const value = config[key];
      if (typeof value !== "undefined") {
        options[key] = value;
      }
    }
  }
  return options;
}
function compose(...funcs) {
  if (funcs.length === 0) {
    return (arg) => arg;
  }
  if (funcs.length === 1) {
    return funcs[0];
  }
  return funcs.reduce(
    (a, b) => (...args) => a(b(...args))
  );
}
function defaultRenderCell({
  row,
  column,
  $index
}) {
  var _a;
  const property = column.property;
  const value = property && objects.getProp(row, property).value;
  if (column && column.formatter) {
    return column.formatter(row, column, value, $index);
  }
  return ((_a = value == null ? void 0 : value.toString) == null ? void 0 : _a.call(value)) || "";
}
function treeCellPrefix({ row, treeNode, store }, createPlaceholder = false) {
  if (!treeNode) {
    if (createPlaceholder) {
      return [
        vue.h("span", {
          class: "ivue-table-indent--placeholder"
        })
      ];
    }
    return null;
  }
  const ele = [];
  const callback = (event) => {
    event.stopPropagation();
    if (treeNode.loading) {
      return;
    }
    store.loadOrToggle(row);
  };
  if (treeNode.indent) {
    ele.push(
      vue.h("span", {
        class: "ivue-table-indent",
        style: {
          "padding-left": `${treeNode.indent}px`
        }
      })
    );
  }
  if (typeof treeNode.expanded === "boolean" && !treeNode.noLazyChildren) {
    const expandClasses = [
      "ivue-table--expand-icon",
      {
        ["ivue-table--expand-icon__expandend"]: treeNode.expanded
      }
    ];
    let icon = "chevron_right";
    if (treeNode.loading) {
      icon = "";
    }
    ele.push(
      vue.h(
        "div",
        {
          class: expandClasses,
          onClick: callback
        },
        {
          default: () => {
            return [
              icon ? vue.h(index["default"], null, {
                default: () => icon
              }) : vue.h(loading["default"])
            ];
          }
        }
      )
    );
  } else {
    ele.push(
      vue.h("span", {
        class: "ivue-table-indent--placeholder"
      })
    );
  }
  return ele;
}
const cellForced = {
  selection: {
    renderHeader({ store }) {
      return vue.h(index$1["default"], {
        disabled: store.states.data.value && store.states.data.value.length === 0,
        modelValue: store.states.isAllSelected.value,
        "onUpdate:modelValue": store.toggleAllSelection,
        indeterminate: store.states.selection.value.length > 0 && !store.states.isAllSelected.value,
        onClick: (event) => {
          event.stopPropagation();
        }
      });
    },
    renderCell({
      row,
      column,
      store,
      $index
    }) {
      return vue.h(index$1["default"], {
        disabled: column.selectable ? !column.selectable.call(null, row, $index) : false,
        modelValue: store.isSelected(row),
        onChange: () => {
          store.commit("rowSelectedChanged", row);
        },
        onClick: (event) => event.stopPropagation()
      });
    },
    sortable: false,
    resizable: false
  },
  index: {
    renderHeader({ column }) {
      return column.label || "#";
    },
    renderCell({ column, $index }) {
      let i = $index + 1;
      const index = column.index;
      if (typeof index === "number") {
        i = $index + index;
      } else if (typeof index === "function") {
        i = index($index);
      }
      return vue.h("div", {}, [i]);
    }
  },
  expand: {
    renderHeader({ column }) {
      return column.label || "";
    },
    renderCell({
      row,
      store,
      expanded
    }) {
      const handleToggleRowExpansion = (event) => {
        event.stopPropagation();
        store.toggleRowExpansion(row);
      };
      return vue.h(
        "div",
        {
          class: [
            "ivue-table--expand-icon",
            {
              ["ivue-table--expand-icon__expandend"]: expanded
            }
          ],
          onClick: handleToggleRowExpansion
        },
        {
          default: () => {
            return [
              vue.h(index["default"], null, {
                default: () => "chevron_right"
              })
            ];
          }
        }
      );
    },
    sortable: false,
    resizable: false
  }
};
const getDefaultClassName = (type) => {
  return defaultClassNames[type] || "";
};

exports.cellForced = cellForced;
exports.cellStyles = cellStyles;
exports.compose = compose;
exports.defaultRenderCell = defaultRenderCell;
exports.getDefaultClassName = getDefaultClassName;
exports.mergeOptions = mergeOptions;
exports.treeCellPrefix = treeCellPrefix;
//# sourceMappingURL=config.js.map