tanxin-ui 0.2.0

package/lib/table/src/table-body.d.ts

@@ -0,0 +1,129 @@
+import type { PropType } from 'vue';
+import type { StrOrNumber, Width } from '../../utils/type';
+import type { Column } from './context';
+declare const _default: import("vue").DefineComponent<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    columns: {
+        type: PropType<Column[]>;
+        default: () => any[];
+    };
+    width: PropType<Width>;
+    maxHeight: PropType<Width>;
+    rowHeight: {
+        type: PropType<Width>;
+        default: number;
+    };
+    virtualList: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clickSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    dblclickSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    multipleSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    rowKey: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    disableRowKeys: {
+        type: PropType<StrOrNumber[]>;
+        default: () => any[];
+    };
+    startIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    endIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    tableSlots: ObjectConstructor;
+}, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:data"[], "update:data", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    columns: {
+        type: PropType<Column[]>;
+        default: () => any[];
+    };
+    width: PropType<Width>;
+    maxHeight: PropType<Width>;
+    rowHeight: {
+        type: PropType<Width>;
+        default: number;
+    };
+    virtualList: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    clickSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    dblclickSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    multipleSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    rowKey: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    disableRowKeys: {
+        type: PropType<StrOrNumber[]>;
+        default: () => any[];
+    };
+    startIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    endIndex: import("vue-types").VueTypeValidableDef<number> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    tableSlots: ObjectConstructor;
+}>> & {
+    "onUpdate:data"?: (...args: any[]) => any;
+}, {
+    size: string;
+    columns: Column[];
+    rowHeight: Width;
+    virtualList: boolean;
+    multipleSelect: boolean;
+    rowKey: string;
+    clickSelect: boolean;
+    dblclickSelect: boolean;
+    disableRowKeys: StrOrNumber[];
+    startIndex: number;
+    endIndex: number;
+}>;
+export default _default;

package/lib/table/src/table-body.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var context = require("./context.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+var tableHeader = require("./table-header.js");
+var index = require("../../radio/index.js");
+var index$1 = require("../../checkbox/index.js");
+var dayjs = require("dayjs");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var dayjs__default = /* @__PURE__ */ _interopDefaultLegacy(dayjs);
+const tableBodyProps = {
+  size: type.PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  columns: {
+    type: Array,
+    default: () => []
+  },
+  width: [String, Number],
+  maxHeight: [String, Number],
+  rowHeight: {
+    type: [String, Number],
+    default: 45
+  },
+  virtualList: type.PropTypes.bool.def(false),
+  clickSelect: type.PropTypes.bool.def(false),
+  dblclickSelect: type.PropTypes.bool.def(false),
+  multipleSelect: type.PropTypes.bool.def(false),
+  rowKey: type.PropTypes.string.def("__key"),
+  disableRowKeys: {
+    type: Array,
+    default: () => []
+  },
+  startIndex: type.PropTypes.number.def(0),
+  endIndex: type.PropTypes.number.def(0),
+  tableSlots: Object
+};
+var TTableBody = vue.defineComponent({
+  name: "TTableBody",
+  components: {
+    TRadio: index.TRadio,
+    TCheckbox: index$1.TCheckbox
+  },
+  inheritAttrs: false,
+  props: tableBodyProps,
+  emits: ["update:data"],
+  setup(props) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("table", props);
+    const tableContext = context.injectTable();
+    const focusedRowKey = vue.ref("");
+    const handleRowSelectChange = (checked, rowData) => {
+      tableContext.setRowSelected(checked, rowData);
+    };
+    const getColumnValue = (rowData, column) => {
+      var _a;
+      if (column.field.indexOf(".") < 0)
+        return getFormatData((_a = rowData[column.field]) != null ? _a : "", column);
+      let label = rowData;
+      const fieldArr = column.field.split(".");
+      for (let i = 0; i < fieldArr.length; i++) {
+        const item = fieldArr[i];
+        if (!label.hasOwnProperty(item))
+          return "";
+        label = label[item];
+      }
+      return getFormatData(label, column);
+    };
+    const getFormatData = (value, column) => {
+      if (column.timeFormat) {
+        if (value)
+          return dayjs__default["default"](value.toString()).format(column.timeFormat);
+        else
+          return "";
+      }
+      return value;
+    };
+    const getColumnData = (column, rowData) => {
+      var _a;
+      const value = getColumnValue(rowData, column);
+      if (!column.hasOwnProperty("dictionary"))
+        return value;
+      if (column.dictionary == null)
+        return value;
+      const item = column.dictionary.find((x) => x[column.valueKey] == value);
+      return (_a = item == null ? void 0 : item[column.labelKey]) != null ? _a : "";
+    };
+    const getTdData = (column, rowData, rowIndex) => {
+      var _a;
+      switch (column.type) {
+        case "select":
+          const checked = tableContext.selectedRowKeys.value.includes(rowData[props.rowKey]);
+          if (props.multipleSelect) {
+            return vue.createVNode(vue.resolveComponent("t-checkbox"), {
+              "size": "lg",
+              "key": rowData[props.rowKey],
+              "value": checked,
+              "disabled": props.disableRowKeys.includes(rowData[props.rowKey]),
+              "bool": true,
+              "onChange": (checked2) => handleRowSelectChange(checked2, rowData)
+            }, null);
+          } else
+            return vue.createVNode(vue.resolveComponent("t-radio"), {
+              "value": tableContext.selectedRowKeys.value[0],
+              "key": rowData[props.rowKey],
+              "size": "lg",
+              "label": rowData[props.rowKey],
+              "item-value": rowData[props.rowKey],
+              "disabled": props.disableRowKeys.includes(rowData[props.rowKey]),
+              "onChange": (checked2) => handleRowSelectChange(checked2, rowData)
+            }, null);
+        case "index":
+          if (props.virtualList)
+            rowIndex += props.startIndex;
+          if (column["render"])
+            return column["render"](rowData, rowIndex, column);
+          else
+            return rowIndex + 1;
+        default:
+          if (column["render"])
+            return column["render"](rowData, rowIndex, column);
+          else if ((_a = props.tableSlots) == null ? void 0 : _a.hasOwnProperty(column["field"])) {
+            return props.tableSlots[column["field"]]({
+              data: rowData,
+              index: rowIndex,
+              column
+            });
+          }
+          return getColumnData(column, rowData);
+      }
+    };
+    const getTdElements = (rowIndex) => {
+      const result = props.columns.map((column) => {
+        var _a, _b;
+        const align = tableHeader.getAlign(column);
+        const direction = tableHeader.getDirection(column);
+        const style = {};
+        if ((_a = column.color) != null ? _a : "")
+          style.color = column.color;
+        if ((_b = column.bold) != null ? _b : false)
+          style.fontWeight = "bold";
+        const tdProps = {
+          class: [`${prefixCls.value}-td`, {
+            [`align-${align}`]: true,
+            [`dir-${direction}`]: direction != "row"
+          }],
+          style
+        };
+        return vue.createVNode("td", null, [vue.createVNode("div", tdProps, [getTdData(column, tableContext.displayDataList.value[rowIndex], rowIndex)])]);
+      });
+      return result;
+    };
+    const getEmdptyElement = () => {
+      const columnCount = props.columns.length;
+      const tdProps = {
+        class: [`${prefixCls.value}-td`, `align-center`]
+      };
+      return vue.createVNode("tr", {
+        "class": "is-empty"
+      }, [vue.createVNode("td", {
+        "colspan": columnCount
+      }, [vue.createVNode("div", tdProps, [vue.createTextVNode("\u6682\u65E0\u6570\u636E")])])]);
+    };
+    const selectRow = (rowData) => {
+      if (props.multipleSelect) {
+        tableContext.setRowSelected(!tableContext.selectedRowKeys.value.includes(rowData[props.rowKey]), rowData);
+      } else {
+        tableContext.setRowSelected(true, rowData);
+      }
+    };
+    const getTrProps = (rowData) => {
+      const theProps = {};
+      theProps["onClick"] = (event) => {
+        event.stopPropagation();
+        focusedRowKey.value = rowData[props.rowKey];
+        if (props.clickSelect)
+          selectRow(rowData);
+      };
+      if (props.dblclickSelect) {
+        theProps["onDblclick"] = (event) => {
+          event.stopPropagation();
+          selectRow(rowData);
+        };
+      }
+      return theProps;
+    };
+    const getTrClasses = (data) => {
+      return [{
+        [`is-focus`]: focusedRowKey.value == data[props.rowKey],
+        [`is-selected`]: tableContext.selectedRowKeys.value.includes(data[props.rowKey])
+      }];
+    };
+    const render = () => {
+      const isEmpty = tableContext.displayDataList.value.length <= 0;
+      return vue.createVNode(vue.Fragment, null, [vue.createVNode("tbody", null, [isEmpty ? getEmdptyElement() : tableContext.displayDataList.value.map((data, rowIndex) => {
+        return vue.createVNode("tr", vue.mergeProps(getTrProps(data), {
+          "class": getTrClasses(data)
+        }), [getTdElements(rowIndex)]);
+      })])]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = TTableBody;

package/lib/table/src/table-header.d.ts

@@ -0,0 +1,111 @@
+import type { PropType } from 'vue';
+import type { Width } from '../../utils/type';
+import type { Column } from './context';
+export declare const getWidth: (column: Column) => string;
+export declare const getAlign: (column: Column) => import("./context").CellAlign;
+export declare const getDirection: (column: Column) => "desc" | "row" | "asc";
+declare const _default: import("vue").DefineComponent<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    columns: {
+        type: PropType<Column[]>;
+        default: () => any[];
+    };
+    width: PropType<Width>;
+    maxHeight: PropType<Width>;
+    rowHeight: {
+        type: PropType<Width>;
+        default: number;
+    };
+    fixed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    headerFixed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    virtualList: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    multipleSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    rowKey: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}, {
+    render: () => JSX.Element;
+    colgroupElements: import("vue").ComputedRef<JSX.Element>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:data"[], "update:data", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: import("vue-types").VueTypeDef<string> & {
+        default: string;
+    };
+    columns: {
+        type: PropType<Column[]>;
+        default: () => any[];
+    };
+    width: PropType<Width>;
+    maxHeight: PropType<Width>;
+    rowHeight: {
+        type: PropType<Width>;
+        default: number;
+    };
+    fixed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    headerFixed: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    virtualList: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    multipleSelect: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    rowKey: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    showHeader: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:data"?: (...args: any[]) => any;
+}, {
+    fixed: boolean;
+    size: string;
+    columns: Column[];
+    showHeader: boolean;
+    rowHeight: Width;
+    headerFixed: boolean;
+    virtualList: boolean;
+    multipleSelect: boolean;
+    rowKey: string;
+}>;
+export default _default;

package/lib/table/src/table-header.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var vue = require("vue");
+var type = require("../../utils/type.js");
+var context = require("./context.js");
+var useConfig = require("../../utils/hooks/useConfig.js");
+var common = require("../../utils/common.js");
+var index = require("../../checkbox/index.js");
+var nanoid = require("nanoid");
+require("../../utils/components/icons/Checkmark.js");
+require("../../utils/components/icons/CheckmarkCircle.js");
+require("../../utils/components/icons/CheckmarkSharp.js");
+require("../../utils/components/icons/CheckmarkCircleOutline.js");
+require("../../utils/components/icons/AlertCircle.js");
+require("../../utils/components/icons/AlertCircleOutline.js");
+require("../../utils/components/icons/InformationCircle.js");
+require("../../utils/components/icons/InformationCircleOutline.js");
+require("../../utils/components/icons/CloseCircle.js");
+require("../../utils/components/icons/CloseCircleOutline.js");
+require("../../utils/components/icons/HelpCircleSharp.js");
+require("../../utils/components/icons/EyeOffOutline.js");
+require("../../utils/components/icons/EyeOutline.js");
+require("../../utils/components/icons/LoadingOutlined.js");
+require("../../utils/components/icons/Close.js");
+require("../../utils/components/icons/CloseOutline.js");
+require("../../utils/components/icons/ArrowsMaximize.js");
+require("../../utils/components/icons/ArrowsMinimize.js");
+require("../../utils/components/icons/AddOutline.js");
+require("../../utils/components/icons/RemoveOutline.js");
+require("../../utils/components/icons/ChevronUp.js");
+require("../../utils/components/icons/ChevronDown.js");
+require("../../utils/components/icons/ChevronForward.js");
+require("../../utils/components/icons/ChevronLeft24Filled.js");
+require("../../utils/components/icons/ChevronRight24Filled.js");
+require("../../utils/components/icons/ChevronDoubleLeft16Filled.js");
+require("../../utils/components/icons/ChevronDoubleRight16Filled.js");
+require("../../utils/components/icons/CheckmarkOutline.js");
+require("../../utils/components/icons/IosCheckmark.js");
+require("../../utils/components/icons/Empty.js");
+require("../../utils/components/icons/Bars.js");
+require("../../utils/components/icons/ArrowUpCircle.js");
+require("../../utils/components/icons/ArrowUp.js");
+require("../../utils/components/icons/ArrowForward.js");
+require("../../utils/components/icons/TimeOutline.js");
+require("../../utils/components/icons/CalendarClearOutline.js");
+require("../../utils/components/icons/KeyboardArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardArrowRightRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowLeftRound.js");
+require("../../utils/components/icons/KeyboardDoubleArrowRightRound.js");
+require("../../utils/components/icons/MenuFoldOutlined.js");
+require("../../utils/components/icons/IosArrowDown.js");
+require("../../utils/components/icons/IosArrowBack.js");
+require("../../utils/components/icons/IosArrowForward.js");
+require("../../utils/components/icons/ImageSharp.js");
+require("../../utils/components/icons/Pause.js");
+require("../../utils/components/icons/Refresh.js");
+require("../../utils/components/icons/QuestionCircle24Regular.js");
+require("../../utils/components/icons/CloudUploadOutline.js");
+require("../../utils/components/icons/UploadFileFilled.js");
+require("../../utils/components/icons/EllipsisHorizontal.js");
+require("../../utils/components/icons/ArrowNext24Filled.js");
+require("../../utils/components/icons/ArrowPrevious24Filled.js");
+var ArrowDropDownSharp = require("../../utils/components/icons/ArrowDropDownSharp.js");
+var ArrowDropUpSharp = require("../../utils/components/icons/ArrowDropUpSharp.js");
+require("../../utils/components/icons/ArrowForwardIosFilled.js");
+const tableHeaderProps = {
+  size: type.PropTypes.oneOf(["xs", "sm", "md", "lg", "xl"]).def("md"),
+  columns: {
+    type: Array,
+    default: () => []
+  },
+  width: [String, Number],
+  maxHeight: [String, Number],
+  rowHeight: {
+    type: [String, Number],
+    default: 45
+  },
+  fixed: type.PropTypes.bool.def(false),
+  headerFixed: type.PropTypes.bool.def(false),
+  virtualList: type.PropTypes.bool.def(false),
+  multipleSelect: type.PropTypes.bool.def(false),
+  rowKey: type.PropTypes.string.def("__key"),
+  showHeader: type.PropTypes.bool.def(true)
+};
+const getWidth = (column) => {
+  return column["width"] ? common.getLength(column["width"]) : "";
+};
+const getAlign = (column) => {
+  return column["align"] || "left";
+};
+const getDirection = (column) => {
+  return column["direction"] || "row";
+};
+var TTableHeader = vue.defineComponent({
+  name: "TTableHeader",
+  components: {
+    TCheckbox: index.TCheckbox
+  },
+  inheritAttrs: false,
+  props: tableHeaderProps,
+  emits: ["update:data"],
+  setup(props) {
+    const {
+      prefixCls
+    } = useConfig.useConfig("table", props);
+    const tableContext = context.injectTable();
+    const columns = vue.ref(props.columns);
+    const sortColumns = vue.ref([]);
+    const colgroupElements = vue.computed(() => {
+      return vue.createVNode("colgroup", null, [columns.value.map((column) => {
+        const width = getWidth(column);
+        const style = {};
+        if (width)
+          style["width"] = width;
+        return vue.createVNode("col", {
+          "style": style
+        }, null);
+      })]);
+    });
+    const handleSelectAll = (value) => {
+      tableContext.setAllSelected(value);
+    };
+    const getThContent = (column) => {
+      switch (column["type"]) {
+        case "select":
+          return props.multipleSelect ? vue.createVNode(vue.resolveComponent("t-checkbox"), {
+            "value": tableContext.allSelected.value,
+            "indeterminate": tableContext.indeterminate.value,
+            "bool": true,
+            "key": nanoid.nanoid(10),
+            "size": "lg",
+            "onChange": handleSelectAll
+          }, null) : null;
+        case "index":
+          return column.title || "\u5E8F\u53F7";
+        default:
+          return column.title;
+      }
+    };
+    const handleSortClick = (column) => {
+      if (!sortColumns.value.includes(column.field)) {
+        column.direction = "";
+      }
+      if (column.direction == "asc") {
+        column.direction = "desc";
+      } else if (column.direction == "desc") {
+        column.direction = "";
+      } else {
+        column.direction = "asc";
+      }
+      sortColumns.value = [column.field];
+      let sorter = column.sorter;
+      if (sorter !== "remote") {
+        if (column.direction == "")
+          return;
+        if (!type.isFunction(sorter)) {
+          sorter = (a, b) => {
+            if (column.type == "number")
+              return a[column.field] - b[column.field];
+            return a[column.field].localeCompare(b[column.field], "zh");
+          };
+        }
+        tableContext.dataSort(sorter, column.direction);
+      } else {
+        tableContext.remoteSort(column);
+      }
+    };
+    const headerThElements = vue.computed(() => {
+      return props.columns.map((column) => {
+        const align = getAlign(column);
+        const direction = getDirection(column);
+        const thProps = {
+          class: [`${prefixCls.value}-td`, {
+            [`align-${align}`]: true,
+            [`dir-${direction}`]: direction != "row"
+          }]
+        };
+        const titleProps = {};
+        if (column.hasOwnProperty("sorter") && column.sorter !== false) {
+          titleProps["onClick"] = () => handleSortClick(column);
+        }
+        return vue.createVNode("th", null, [vue.createVNode("div", thProps, [vue.createVNode("div", vue.mergeProps({
+          "class": [`${prefixCls.value}-title`, {
+            [`with-sort`]: column.hasOwnProperty("sorter") && column.sorter !== false
+          }]
+        }, titleProps), [getThContent(column), vue.createTextVNode(" "), getThSort(column)])])]);
+      });
+    });
+    const getThSort = (column) => {
+      return column.hasOwnProperty("sorter") && column.sorter !== false ? vue.createVNode("span", {
+        "class": `${prefixCls.value}-sort`
+      }, [vue.createVNode(vue.resolveComponent("t-icon"), {
+        "class": [{
+          [`active`]: sortColumns.value.includes(column.field) && column.direction == "asc"
+        }]
+      }, {
+        default: () => [vue.createVNode(ArrowDropUpSharp["default"], null, null)]
+      }), vue.createVNode(vue.resolveComponent("t-icon"), {
+        "class": [{
+          [`active`]: sortColumns.value.includes(column.field) && column.direction == "desc"
+        }]
+      }, {
+        default: () => [vue.createVNode(ArrowDropDownSharp["default"], null, null)]
+      })]) : null;
+    };
+    vue.watch(() => tableContext.allSelected.value, () => {
+      console.log("watch", "tableContext.allSelected.value", tableContext.allSelected.value);
+    });
+    const render = () => {
+      return vue.createVNode(vue.Fragment, null, [colgroupElements.value, props.showHeader ? vue.createVNode("thead", null, [vue.createVNode("tr", null, [headerThElements.value])]) : null]);
+    };
+    return {
+      render,
+      colgroupElements
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+exports["default"] = TTableHeader;
+exports.getAlign = getAlign;
+exports.getDirection = getDirection;
+exports.getWidth = getWidth;