@fangzhongya/fang-ui 0.0.12 → 0.0.14

package/dist/components/lists/src/index.js

@@ -0,0 +1,336 @@
+import { defineComponent, ref, computed, onMounted, h } from "vue";
+import { setLabel, setSslot } from "./util.js";
+import { setStyles } from "../../common/css.js";
+import { useHide, uesObjComponSelected } from "../../common/use.js";
+import { getCompons } from "../../common/compons.js";
+import { useCssName } from "../../../hooks/cssname/index.js";
+import { dataProps, dataExpose, dataEmits } from "./data.js";
+import FImg from "../common/img.js";
+const Components = {
+  Img: FImg
+};
+const _sfc_main = defineComponent({
+  emits: dataEmits,
+  components: Components,
+  expose: dataExpose,
+  props: dataProps,
+  setup(props, { emit, slots }) {
+    const compons = getCompons(props.compons);
+    const cs = useCssName("lists");
+    const isfocus = ref(false);
+    const rowObj = ref();
+    const borderColor = computed(() => {
+      const d = "#ccc";
+      if (typeof props.border === "boolean") {
+        return d;
+      } else {
+        return props.border ?? d;
+      }
+    });
+    function isComponSelected(obj) {
+      if (uesObjComponSelected(obj, props)) {
+        if (rowObj.value == obj) {
+          if (isfocus.value) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+    const getLists = (arrs, listobj) => {
+      let arr = [], trs = [], lin = 0;
+      arrs.forEach((obj, index) => {
+        if (listobj) {
+          obj.father = obj.father ?? listobj;
+        }
+        if (!useHide(obj, props.value)) {
+          let is = false;
+          if (obj.whole) {
+            lin = props.column;
+            is = true;
+          } else {
+            let k = (obj.column || 1) + lin;
+            if (k > props.column) {
+              lin = obj.column || 1;
+              is = true;
+            } else {
+              lin = k;
+              is = false;
+            }
+          }
+          if (is) {
+            arr.push(h("tr", {}, trs));
+            trs = [];
+          }
+          trs.push(...getTd(obj, index));
+          if (lin >= props.column) {
+            arr.push(h("tr", {}, trs));
+            trs = [];
+            lin = 0;
+          }
+        }
+      });
+      if (trs.length > 0) {
+        arr.push(h("tr", {}, trs));
+      }
+      return arr;
+    };
+    const getListTops = (arrs, listobj) => {
+      let arr = [], trvs = [], trls = [], lin = 0;
+      arrs.forEach((obj, index) => {
+        if (listobj) {
+          obj.father = obj.father ?? listobj;
+        }
+        if (!useHide(obj, props.value)) {
+          let is = false;
+          if (obj.whole) {
+            lin = props.column;
+            is = true;
+          } else {
+            let k = (obj.column || 1) + lin;
+            if (k > props.column) {
+              lin = obj.column || 1;
+              is = true;
+            } else {
+              lin = k;
+              is = false;
+            }
+          }
+          if (is) {
+            arr.push(h("tr", {}, trls));
+            trls = [];
+            arr.push(h("tr", {}, trvs));
+            trvs = [];
+          }
+          if (obj.isdiv) {
+            trls.push(getValue(obj, index, true));
+          } else {
+            trls.push(getlabel(obj, index));
+            trvs.push(getValue(obj, index));
+          }
+          if (lin >= props.column) {
+            arr.push(h("tr", {}, trls));
+            arr.push(h("tr", {}, trvs));
+            trls = [];
+            trvs = [];
+            lin = 0;
+          }
+        }
+      });
+      if (trls.length > 0) {
+        arr.push(h("tr", {}, trls));
+        arr.push(h("tr", {}, trvs));
+      }
+      return arr;
+    };
+    const getlabel = (obj, index) => {
+      return h(
+        "th",
+        {
+          style: {
+            width: obj.labelWidth ?? props.labelWidth
+          },
+          class: [
+            cs.z("table-th"),
+            cs.is("whole", obj.whole),
+            obj.class ?? ""
+          ].join(" "),
+          colspan: props.labelPosition == "top" ? setColspan(obj) : void 0,
+          onClick: (event) => {
+            isfocus.value = true;
+            rowObj.value = obj;
+            event.stopPropagation();
+            return false;
+          }
+        },
+        [
+          h(
+            "span",
+            {
+              class: cs.z("table-label")
+            },
+            [
+              setLabel(
+                obj,
+                props,
+                compons,
+                emit,
+                slots,
+                isComponSelected,
+                index
+              )
+            ]
+          )
+        ]
+      );
+    };
+    const getChildrenValue = (obj, index) => {
+      if (obj.children) {
+        return [
+          h(
+            "div",
+            {
+              class: cs.z("table-children")
+            },
+            [
+              props.labelPosition == "top" ? getListTops(obj.children, obj) : getLists(obj.children, obj)
+            ]
+          )
+        ];
+      } else {
+        return [
+          h(
+            "span",
+            {
+              class: cs.z("table-value")
+            },
+            [
+              setSslot(
+                obj,
+                props.value,
+                props,
+                compons,
+                emit,
+                slots,
+                isComponSelected,
+                index
+              )
+            ]
+          )
+        ];
+      }
+    };
+    const getValue = (obj, index, isRow) => {
+      return h(
+        "td",
+        {
+          style: setStyles(obj, props.value, props),
+          class: [
+            cs.z("table-td"),
+            cs.is("whole", obj.whole),
+            obj.class ?? ""
+          ].join(" "),
+          colspan: setColspan(obj),
+          rowspan: isRow ? 2 : void 0,
+          onClick: (event) => {
+            isfocus.value = true;
+            rowObj.value = obj;
+            event.stopPropagation();
+            return false;
+          }
+        },
+        [...getChildrenValue(obj, index)]
+      );
+    };
+    const getTd = (obj, index) => {
+      const arr = [getValue(obj, index)];
+      if (!obj.isdiv) {
+        arr.unshift(getlabel(obj, index));
+      }
+      if (props.labelPosition == "auto") {
+        return [
+          h(
+            "td",
+            {
+              colspan: setColspan(obj),
+              class: cs.is("whole", obj.whole)
+            },
+            [
+              h(
+                "div",
+                {
+                  class: cs.z("table-auto")
+                },
+                arr
+              )
+            ]
+          )
+        ];
+      } else {
+        return arr;
+      }
+    };
+    const setColspan = (obj) => {
+      if (["auto", "top"].includes(props.labelPosition)) {
+        if (obj.whole) {
+          return props.column;
+        } else if (obj.column) {
+          return obj.column;
+        } else {
+          return "";
+        }
+      } else {
+        const j = !obj.isdiv ? 0 : 1;
+        if (obj.whole) {
+          return (props.column - 1) * 2 + 1 + j;
+        } else if (obj.column) {
+          return (obj.column - 1) * 2 + 1 + j;
+        } else {
+          return 1 + j;
+        }
+      }
+    };
+    const renderValue = () => {
+      if (props.list && props.list.length > 0) {
+        return h(
+          "div",
+          {
+            class: cs.z("div"),
+            style: cs.vdo({
+              borderColor: borderColor.value
+            })
+            // onClick(event: Event) {
+            // 	isfocus.value = true;
+            // 	event.stopPropagation();
+            // 	return false;
+            // },
+          },
+          [
+            h(
+              "table",
+              {
+                class: [
+                  cs.z("table"),
+                  props.labelPosition ?? "",
+                  cs.is(
+                    "border",
+                    props.border ? true : false
+                  ),
+                  cs.is("aliquots", props.aliquots)
+                ].join(" "),
+                cellspacing: "0",
+                cellpadding: "0",
+                border: "0"
+              },
+              props.labelPosition == "top" ? getListTops(props.list) : getLists(props.list)
+            )
+          ]
+        );
+      } else {
+        return "";
+      }
+    };
+    onMounted(() => {
+      if (window) {
+        window.addEventListener("click", () => {
+          isfocus.value = false;
+        });
+      }
+    });
+    return {
+      renderValue,
+      borderColor
+    };
+  },
+  render(props) {
+    return props.renderValue();
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/lists/src/index2.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_vue_vue_type_script_lang = require("./index.cjs");
+exports.default = index_vue_vue_type_script_lang.default;

package/dist/components/lists/src/index2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./index.js";
+export {
+  _sfc_main as default
+};

package/dist/components/lists/src/setup.d.ts

@@ -0,0 +1,9 @@
+import { VNode, Component } from 'vue';
+import { UseCssNameReturn } from '../../../hooks/cssname';
+type Compons = {
+    [key: string]: Component;
+};
+export declare function render(props: ObjAny, emit: Function, slots: ObjAny, cs: UseCssNameReturn, compons: Compons): "" | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;
+export {};

package/dist/components/lists/src/util.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("vue");
+const use = require("../../common/use.cjs");
+require("@fangzhongya/utils/basic/string/splitUpper");
+require("@fangzhongya/utils/basic/array/isArray");
+const isObject = require("@fangzhongya/utils/basic/object/isObject");
+require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+require("@fangzhongya/utils/name/lineToLargeHump");
+require("@fangzhongya/utils/name/lineToSmallHump");
+require("@fangzhongya/utils/name/humpToLine");
+require("@fangzhongya/utils/basic/object/deepCopy");
+require("@fangzhongya/utils/basic/Array/toggleArray");
+require("@fangzhongya/utils/basic/object/objValue");
+function setSslot(obj, data, props, compons, emit, slots, isComponSelected, index) {
+  const slot = use.useSetSlot(obj, data, slots, index);
+  if (slot) {
+    return slot;
+  }
+  const optionss = props.options || {};
+  if (obj.compon) {
+    if (isComponSelected(obj)) {
+      const column = use.useSetCompon(
+        obj,
+        data,
+        optionss,
+        compons,
+        emit,
+        index
+      );
+      if (column) {
+        return column;
+      }
+    }
+  }
+  return use.useGetDomValue(obj, data, optionss, index);
+}
+function setLabel(obj, props, compons, emit, slots, isComponSelected, index) {
+  let label = obj.label ?? "";
+  if (label) {
+    if (isObject.isObject(label)) {
+      label = Object.assign({}, obj, label);
+      const slot = use.useSetSlot(label, props.value, slots, index);
+      if (slot) {
+        return slot;
+      }
+      if (label.compon) {
+        if (isComponSelected(obj)) {
+          const column = use.useSetCompon(
+            label,
+            props.value,
+            props.optionss,
+            compons,
+            emit,
+            index
+          );
+          if (column) {
+            return column;
+          }
+        }
+      }
+      label = use.useGetDomValue(label, props.value, props.optionss, index);
+    }
+  }
+  let colon = props.colon;
+  if (colon) {
+    if (colon === true) {
+      colon = "：";
+    }
+    if (label) {
+      return label + colon;
+    }
+  }
+  return label;
+}
+exports.setLabel = setLabel;
+exports.setSslot = setSslot;

package/dist/components/lists/src/util.d.ts

@@ -0,0 +1,8 @@
+import { Component } from 'vue';
+type Compons = {
+    [key: string]: Component;
+};
+export declare const setClass: (item: ListObj, data: ObjStr, index: number) => any;
+export declare function setSslot(obj: ListObj, data: ObjAny, props: ObjAny, compons: Compons, emit: Function, slots: ObjAny, isComponSelected: Function, index?: number): any;
+export declare function setLabel(obj: ListObj, props: ObjAny, compons: Compons, emit: Function, slots: ObjAny, isComponSelected: Function, index?: number): any;
+export {};

package/dist/components/lists/src/util.js

@@ -0,0 +1,79 @@
+import "vue";
+import { useSetSlot, useSetCompon, useGetDomValue } from "../../common/use.js";
+import "@fangzhongya/utils/basic/string/splitUpper";
+import "@fangzhongya/utils/basic/array/isArray";
+import { isObject } from "@fangzhongya/utils/basic/object/isObject";
+import "@fangzhongya/utils/basic/string/firstLower";
+import "@fangzhongya/utils/basic/object/hasOwn";
+import "@fangzhongya/utils/basic/string/firstUpper";
+import "@fangzhongya/utils/name/lineToLargeHump";
+import "@fangzhongya/utils/name/lineToSmallHump";
+import "@fangzhongya/utils/name/humpToLine";
+import "@fangzhongya/utils/basic/object/deepCopy";
+import "@fangzhongya/utils/basic/Array/toggleArray";
+import "@fangzhongya/utils/basic/object/objValue";
+function setSslot(obj, data, props, compons, emit, slots, isComponSelected, index) {
+  const slot = useSetSlot(obj, data, slots, index);
+  if (slot) {
+    return slot;
+  }
+  const optionss = props.options || {};
+  if (obj.compon) {
+    if (isComponSelected(obj)) {
+      const column = useSetCompon(
+        obj,
+        data,
+        optionss,
+        compons,
+        emit,
+        index
+      );
+      if (column) {
+        return column;
+      }
+    }
+  }
+  return useGetDomValue(obj, data, optionss, index);
+}
+function setLabel(obj, props, compons, emit, slots, isComponSelected, index) {
+  let label = obj.label ?? "";
+  if (label) {
+    if (isObject(label)) {
+      label = Object.assign({}, obj, label);
+      const slot = useSetSlot(label, props.value, slots, index);
+      if (slot) {
+        return slot;
+      }
+      if (label.compon) {
+        if (isComponSelected(obj)) {
+          const column = useSetCompon(
+            label,
+            props.value,
+            props.optionss,
+            compons,
+            emit,
+            index
+          );
+          if (column) {
+            return column;
+          }
+        }
+      }
+      label = useGetDomValue(label, props.value, props.optionss, index);
+    }
+  }
+  let colon = props.colon;
+  if (colon) {
+    if (colon === true) {
+      colon = "：";
+    }
+    if (label) {
+      return label + colon;
+    }
+  }
+  return label;
+}
+export {
+  setLabel,
+  setSslot
+};

package/dist/components/menu/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const withInstall = require("../../utils/vues/withInstall.cjs");
+const index_vue_vue_type_script_setup_true_lang = require("./src/index.cjs");
+const Menu = withInstall.withInstall(index_vue_vue_type_script_setup_true_lang.default, "Menu");
+exports.Menu = Menu;
+exports.default = Menu;

package/dist/components/menu/index.d.ts

@@ -0,0 +1,146 @@
+declare const Menu: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: () => ObjAny;
+            default(): {};
+        };
+        compons: {
+            type: () => {
+                [key: string]: import('vue').Component;
+            };
+            default(): {};
+        };
+        level: (BooleanConstructor | StringConstructor)[];
+        value: {
+            type: StringConstructor;
+        };
+        list: {
+            type: {
+                (arrayLength: number): ListObj[];
+                (...items: ListObj[]): ListObj[];
+                new (arrayLength: number): ListObj[];
+                new (...items: ListObj[]): ListObj[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+    }>> & Readonly<{
+        onSelect?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        select: (...args: any[]) => void;
+    }, import('vue').PublicProps, {
+        config: ObjAny;
+        list: ListObj[];
+        compons: {
+            [key: string]: import('vue').Component;
+        };
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        config: {
+            type: () => ObjAny;
+            default(): {};
+        };
+        compons: {
+            type: () => {
+                [key: string]: import('vue').Component;
+            };
+            default(): {};
+        };
+        level: (BooleanConstructor | StringConstructor)[];
+        value: {
+            type: StringConstructor;
+        };
+        list: {
+            type: {
+                (arrayLength: number): ListObj[];
+                (...items: ListObj[]): ListObj[];
+                new (arrayLength: number): ListObj[];
+                new (...items: ListObj[]): ListObj[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+    }>> & Readonly<{
+        onSelect?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        config: ObjAny;
+        list: ListObj[];
+        compons: {
+            [key: string]: import('vue').Component;
+        };
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    config: {
+        type: () => ObjAny;
+        default(): {};
+    };
+    compons: {
+        type: () => {
+            [key: string]: import('vue').Component;
+        };
+        default(): {};
+    };
+    level: (BooleanConstructor | StringConstructor)[];
+    value: {
+        type: StringConstructor;
+    };
+    list: {
+        type: {
+            (arrayLength: number): ListObj[];
+            (...items: ListObj[]): ListObj[];
+            new (arrayLength: number): ListObj[];
+            new (...items: ListObj[]): ListObj[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): never[];
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+}, string, {
+    config: ObjAny;
+    list: ListObj[];
+    compons: {
+        [key: string]: import('vue').Component;
+    };
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: any) => any>>;
+}) & import('vue').Plugin;
+export { Menu, Menu as default };

package/dist/components/menu/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from "../../utils/vues/withInstall.js";
+import _sfc_main from "./src/index.js";
+const Menu = withInstall(_sfc_main, "Menu");
+export {
+  Menu,
+  Menu as default
+};