@opendesign-plus/components 0.0.1-rc.6 → 0.0.1-rc.60

package/dist/treeshaking/components/common/ThFilter.vue.mjs

@@ -0,0 +1,270 @@
+import { defineComponent, computed, ref, watch, resolveComponent, openBlock, createElementBlock, createElementVNode, renderSlot, createBlock, unref, withCtx, createVNode, Fragment, renderList, withDirectives, createTextVNode, toDisplayString, normalizeClass, normalizeStyle, createCommentVNode, nextTick, h } from "vue";
+import { OPopover, OScroller, OCheckboxGroup, OCheckbox, ODivider, OLink, OIcon, ODropdown, ODropdownItem } from "@opensig/opendesign";
+import IconFilter from "../../_virtual/icon-filter.mjs";
+import { useI18n } from "../../i18n/index.mjs";
+import { buildVueDompurifyHTMLDirective } from "vue-dompurify-html";
+const _hoisted_1 = {
+  class: "th-filter-wrapper",
+  ref: "filterRef"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "list-content-wrapper"
+};
+const _hoisted_3 = { class: "btn-wrapper" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ThFilter",
+  props: {
+    modelValue: {},
+    list: { default: () => [] },
+    multiple: { type: Boolean, default: false },
+    tableWidth: {}
+  },
+  emits: ["update:model-value", "confirm"],
+  setup(__props, { emit: __emit }) {
+    const vDompurifyHtml = buildVueDompurifyHTMLDirective();
+    const { t } = useI18n();
+    const props = __props;
+    const emits = __emit;
+    const isCascader = computed(() => props.list.some((v) => {
+      var _a;
+      return (_a = v.children) == null ? void 0 : _a.length;
+    }));
+    const options = computed(() => {
+      return props.list.map((v) => {
+        const children = (v.children || []).map((t2) => {
+          return {
+            label: t2.label,
+            value: t2.value
+          };
+        });
+        return {
+          label: v.label,
+          value: v.value,
+          children: isCascader.value ? children : void 0
+        };
+      });
+    });
+    const visible = ref(false);
+    watch(
+      () => props.modelValue,
+      (val) => {
+        if (!props.multiple) {
+          checked.value = val;
+        } else {
+          multiChecked.value = val;
+        }
+      }
+    );
+    const multiChecked = ref([]);
+    const change = (val) => {
+      multiChecked.value = val;
+    };
+    const cascaderValue = ref([]);
+    const checked = ref(null);
+    const handleCommand = (val) => {
+      if (checked.value === val) {
+        checked.value = null;
+      } else {
+        checked.value = val;
+      }
+      confirmFn();
+    };
+    const reset = () => {
+      multiChecked.value = [];
+      cascaderValue.value = [];
+      checked.value = null;
+      confirmFn();
+    };
+    const confirmFn = () => {
+      let finalValue = null;
+      if (!props.multiple) {
+        finalValue = checked.value;
+      } else if (isCascader.value) {
+        finalValue = cascaderValue.value;
+      } else {
+        finalValue = multiChecked.value;
+      }
+      emits("update:model-value", finalValue);
+      visible.value = true;
+      nextTick(() => {
+        emits("confirm");
+        visible.value = false;
+      });
+    };
+    const hasChecked = computed(() => {
+      return multiChecked.value.length || cascaderValue.value.length || checked.value || props.modelValue;
+    });
+    const aref = ref(null);
+    const clickLabelSpan = async (e) => {
+      var _a, _b;
+      const ele = e.target.parentElement.parentElement;
+      await nextTick();
+      const input = ele.querySelector("input");
+      input.click();
+      await nextTick();
+      (_a = input.change) == null ? void 0 : _a.call(input, input);
+      await nextTick();
+      (_b = aref.value) == null ? void 0 : _b.$forceUpdate();
+      cascaderValue.value = JSON.parse(JSON.stringify(cascaderValue.value));
+    };
+    const renderLabel = ({ data }) => {
+      return h("span", { onclick: clickLabelSpan }, data.label);
+    };
+    return (_ctx, _cache) => {
+      const _component_ElCascaderPanel = resolveComponent("ElCascaderPanel");
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("span", null, [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        __props.multiple ? (openBlock(), createBlock(unref(OPopover), {
+          key: 0,
+          visible: visible.value,
+          position: "bottom",
+          wrapClass: "th-filter-popover",
+          trigger: "click",
+          anchor: false
+        }, {
+          target: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(["filter-wrapper", hasChecked.value && "has-checked"])
+            }, [
+              createVNode(unref(OIcon), { class: "filter-icon" }, {
+                default: withCtx(() => [
+                  createVNode(unref(IconFilter))
+                ]),
+                _: 1
+              })
+            ], 2)
+          ]),
+          default: withCtx(() => [
+            !isCascader.value ? (openBlock(), createBlock(unref(OScroller), {
+              key: 0,
+              class: "content-wrapper",
+              "show-type": "hover",
+              "disabled-x": ""
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(OCheckboxGroup), {
+                  direction: "v",
+                  onChange: change,
+                  modelValue: multiChecked.value,
+                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => multiChecked.value = $event)
+                }, {
+                  default: withCtx(() => [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(options.value, (item) => {
+                      return openBlock(), createBlock(unref(OCheckbox), {
+                        key: item.value,
+                        value: item.value
+                      }, {
+                        default: withCtx(() => [
+                          withDirectives(createElementVNode("span", null, null, 512), [
+                            [unref(vDompurifyHtml), item.label]
+                          ])
+                        ]),
+                        _: 2
+                      }, 1032, ["value"]);
+                    }), 128))
+                  ]),
+                  _: 1
+                }, 8, ["modelValue"])
+              ]),
+              _: 1
+            })) : (openBlock(), createElementBlock("div", _hoisted_2, [
+              createVNode(_component_ElCascaderPanel, {
+                ref_key: "aref",
+                ref: aref,
+                expandTrigger: "hover",
+                renderLabel,
+                modelValue: cascaderValue.value,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => cascaderValue.value = $event),
+                style: { "width": "fit-content" },
+                options: options.value,
+                props: { multiple: true, expandTrigger: "hover" }
+              }, null, 8, ["modelValue", "options"])
+            ])),
+            createVNode(unref(ODivider)),
+            createElementVNode("div", _hoisted_3, [
+              createVNode(unref(OLink), { onClick: reset }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref(t)("common.reset")), 1)
+                ]),
+                _: 1
+              }),
+              createVNode(unref(OLink), { onClick: confirmFn }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref(t)("common.confirm")), 1)
+                ]),
+                _: 1
+              })
+            ])
+          ]),
+          _: 1
+        }, 8, ["visible"])) : (openBlock(), createBlock(unref(ODropdown), {
+          key: 1,
+          optionPosition: "bottom",
+          optionWrapClass: "th-filter-dropdown",
+          modelValue: checked.value,
+          "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => checked.value = $event)
+        }, {
+          dropdown: withCtx(() => [
+            options.value.length ? (openBlock(), createBlock(unref(OScroller), {
+              key: 0,
+              "disabled-x": "",
+              style: { "max-height": "300px" },
+              "show-type": "always"
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(ODropdownItem), {
+                  style: normalizeStyle({
+                    "--table-width": __props.tableWidth
+                  }),
+                  class: normalizeClass([{ "is-active": __props.modelValue === "" }]),
+                  value: "''",
+                  label: unref(t)("common.all"),
+                  onClick: _cache[2] || (_cache[2] = ($event) => handleCommand(""))
+                }, null, 8, ["style", "class", "label"]),
+                (openBlock(true), createElementBlock(Fragment, null, renderList(options.value, (item) => {
+                  return openBlock(), createBlock(unref(ODropdownItem), {
+                    style: normalizeStyle({
+                      "--table-width": __props.tableWidth
+                    }),
+                    class: normalizeClass([{ "is-active": item.value === __props.modelValue }]),
+                    key: item.value,
+                    value: item.value,
+                    onClick: ($event) => handleCommand(item.value)
+                  }, {
+                    default: withCtx(() => [
+                      withDirectives(createElementVNode("span", null, null, 512), [
+                        [unref(vDompurifyHtml), item.label]
+                      ])
+                    ]),
+                    _: 2
+                  }, 1032, ["style", "class", "value", "onClick"]);
+                }), 128))
+              ]),
+              _: 1
+            })) : createCommentVNode("", true),
+            !options.value.length ? renderSlot(_ctx.$slots, "empty", { key: 1 }) : createCommentVNode("", true)
+          ]),
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(["filter-wrapper", hasChecked.value && "has-checked"])
+            }, [
+              createVNode(unref(OIcon), { class: "filter-icon" }, {
+                default: withCtx(() => [
+                  createVNode(unref(IconFilter))
+                ]),
+                _: 1
+              })
+            ], 2)
+          ]),
+          _: 3
+        }, 8, ["modelValue"]))
+      ], 512);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/common/ThFilter.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./ThFilter.vue.mjs";
+import './ThFilter.css';
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/common/TooltipText.css

@@ -0,0 +1,35 @@
+.hover-icon-rotate .o-icon {
+  transition: all var(--o-duration-m1) var(--o-easing-standard-in);
+}
+@media (hover: hover) {
+.hover-icon-rotate:hover .o-icon {
+    transform: rotate(-180deg);
+}
+}
+.tooltip-text-wrapper .tooltip-text {
+  overflow: hidden;
+  word-break: keep-all;
+}
+.tooltip-text-wrapper .tooltip-text.ellipsis {
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.tooltip-text-wrapper .tooltip-text.multi-lines {
+  word-break: break-all;
+  white-space: normal;
+  text-overflow: ellipsis;
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: var(--lines);
+}
+.tooltip-text-wrapper .button {
+  color: var(--o-color-primary1);
+  cursor: pointer;
+}
+.tooltip-text-wrapper .popup-box2 {
+  color: var(--o-color-info2);
+}
+.tooltip-text-wrapper .popup-box2.fz-14 {
+  font-size: 14px;
+  line-height: 22px;
+}

package/dist/treeshaking/components/common/TooltipText.vue.mjs

@@ -0,0 +1,104 @@
+import { defineComponent, ref, useSlots, onMounted, onUnmounted, watch, computed, openBlock, createElementBlock, normalizeStyle, createVNode, unref, withCtx, createElementVNode, normalizeClass, toDisplayString, renderSlot } from "vue";
+import { isClient, OPopover } from "@opensig/opendesign";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TooltipText",
+  props: {
+    lines: {},
+    width: {},
+    type: { default: "" },
+    size: { default: 14 }
+  },
+  setup(__props) {
+    const contentRef = ref(null);
+    const ellipsis = ref(true);
+    const props = __props;
+    const slots = useSlots();
+    let resizeObserver = null;
+    let resizeRafId = null;
+    const checkOverflow = () => {
+      if (!isClient) return;
+      const ele = contentRef.value;
+      if (!ele) return;
+      if (props.lines && props.lines > 1) {
+        const visibleHeight = ele.offsetHeight;
+        const prevDisplay = ele.style.display;
+        ele.style.display = "block";
+        const naturalHeight = ele.scrollHeight;
+        ele.style.display = prevDisplay;
+        if (naturalHeight && visibleHeight) {
+          ellipsis.value = naturalHeight > visibleHeight + 1;
+        }
+        return;
+      }
+      ellipsis.value = ele.scrollWidth > ele.offsetWidth + 1 || ele.scrollHeight > ele.offsetHeight + 1;
+    };
+    const onWindowResize = () => {
+      if (resizeRafId !== null) cancelAnimationFrame(resizeRafId);
+      resizeRafId = requestAnimationFrame(checkOverflow);
+    };
+    onMounted(() => {
+      checkOverflow();
+      if (!isClient || !contentRef.value) return;
+      resizeObserver = new ResizeObserver(() => checkOverflow());
+      resizeObserver.observe(contentRef.value);
+      window.addEventListener("resize", onWindowResize);
+    });
+    onUnmounted(() => {
+      resizeObserver == null ? void 0 : resizeObserver.disconnect();
+      if (resizeRafId !== null) cancelAnimationFrame(resizeRafId);
+      window.removeEventListener("resize", onWindowResize);
+    });
+    watch(() => [props.lines, props.width], () => {
+      if (isClient) requestAnimationFrame(checkOverflow);
+    });
+    const getTextFromNode = (node) => {
+      const children = node.children ?? "";
+      if (Array.isArray(children)) {
+        return children.map((v) => getTextFromNode(v)).join("");
+      }
+      return String(children);
+    };
+    const contentText = computed(() => {
+      var _a;
+      const nodes = ((_a = slots.default) == null ? void 0 : _a.call(slots)) || [];
+      return nodes.map((node) => getTextFromNode(node)).join("\n");
+    });
+    const wrapperStyle = computed(() => {
+      const calcWidth = Number.isNaN(Number(props.width)) ? props.width : `${props.width}px`;
+      return { width: calcWidth };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "tooltip-text-wrapper",
+        style: normalizeStyle(wrapperStyle.value)
+      }, [
+        createVNode(unref(OPopover), {
+          anchor: "",
+          disabled: !ellipsis.value,
+          adjustMinWidth: false,
+          adjustWidth: true
+        }, {
+          target: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(["tooltip-text", __props.type, ellipsis.value && "ellipsis", __props.lines && __props.lines > 1 && "multi-lines"]),
+              ref_key: "contentRef",
+              ref: contentRef,
+              style: normalizeStyle(`--lines: ${__props.lines};`)
+            }, [
+              renderSlot(_ctx.$slots, "default")
+            ], 6)
+          ]),
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass(["popup-box2", `fz-${__props.size}`])
+            }, toDisplayString(contentText.value), 3)
+          ]),
+          _: 3
+        }, 8, ["disabled"])
+      ], 4);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/common/TooltipText.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./TooltipText.vue.mjs";
+import './TooltipText.css';
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/config-provider/OPlusConfigProvider.vue.d.ts

@@ -0,0 +1,24 @@
+export interface OPlusConfigProviderPropsT {
+    locale?: string;
+    theme?: 'light' | 'dark';
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<OPlusConfigProviderPropsT, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<OPlusConfigProviderPropsT> & Readonly<{}>, {
+    locale: string;
+    theme: "light" | "dark";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/treeshaking/components/config-provider/OPlusConfigProvider.vue.mjs

@@ -0,0 +1,33 @@
+import { defineComponent, reactive, computed, provide, openBlock, createBlock, unref, withCtx, renderSlot } from "vue";
+import { OConfigProvider } from "@opensig/opendesign";
+import zhCN from "@opensig/opendesign/es/locale/lang/zh-cn";
+import enUS from "@opensig/opendesign/es/locale/lang/en-us";
+import { configProviderInjectKey } from "../../shared/provide.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "OPlusConfigProvider",
+  props: {
+    locale: { default: "zh" },
+    theme: { default: "light" }
+  },
+  setup(__props) {
+    const props = __props;
+    const globalConfig = reactive({
+      locale: computed(() => props.locale),
+      theme: computed(() => props.theme)
+    });
+    provide(configProviderInjectKey, globalConfig);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(OConfigProvider), {
+        locale: __props.locale === "zh" ? unref(zhCN) : unref(enUS)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["locale"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/config-provider/OPlusConfigProvider.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./OPlusConfigProvider.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/config-provider/index.d.ts

@@ -0,0 +1,30 @@
+import { App } from 'vue';
+declare const OPlusConfigProvider: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./OPlusConfigProvider.vue').OPlusConfigProviderPropsT> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        locale: string;
+        theme: "light" | "dark";
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./OPlusConfigProvider.vue').OPlusConfigProviderPropsT> & Readonly<{}>, {}, {}, {}, {}, {
+        locale: string;
+        theme: "light" | "dark";
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./OPlusConfigProvider.vue').OPlusConfigProviderPropsT> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    locale: string;
+    theme: "light" | "dark";
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & {
+    install(app: App): void;
+};
+export { OPlusConfigProvider };

package/dist/treeshaking/components/config-provider/index.mjs

@@ -0,0 +1,9 @@
+import _sfc_main from "./OPlusConfigProvider.vue.mjs";
+const OPlusConfigProvider = Object.assign(_sfc_main, {
+  install(app) {
+    app.component("OPlusConfigProvider", _sfc_main);
+  }
+});
+export {
+  OPlusConfigProvider
+};

package/dist/treeshaking/components/cookie-notice/OCookieNotice.css

@@ -0,0 +1,35 @@
+.hover-icon-rotate .o-icon {
+  transition: all var(--o-duration-m1) var(--o-easing-standard-in);
+}
+@media (hover: hover) {
+.hover-icon-rotate:hover .o-icon {
+    transform: rotate(-180deg);
+}
+}
+.o-cookie-notice-dlg-main {
+  --dlg-edge-gap: 32px;
+}
+@media (min-width: 1201px) and (max-width: 1680px) {
+.o-cookie-notice-dlg-main {
+    --dlg-edge-gap: 24px;
+}
+}
+@media (max-width: 600px) {
+.o-cookie-notice-dlg-main {
+    --dlg-edge-gap: 16px 24px;
+}
+}
+.o-cookie-notice-dlg-main {
+  --dlg-width: var(--grid-14);
+}
+@media (min-width: 841px) and (max-width: 1200px) {
+.o-cookie-notice-dlg-main {
+    --dlg-edge-gap: 16px;
+    --dlg-width: var(--grid-8);
+}
+}
+@media (max-width: 840px) {
+.o-cookie-notice-dlg-main {
+    --dlg-width: 100vw;
+}
+}

package/dist/treeshaking/components/cookie-notice/OCookieNotice.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    visible?: boolean;
+    community: string;
+    detailUrl: string;
+    wrapper?: string | HTMLElement;
+    cookieDomain: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    check(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:visible": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    cookieNoticeRef: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/treeshaking/components/cookie-notice/OCookieNotice.vue.mjs

@@ -0,0 +1,8 @@
+import _sfc_main from "./OCookieNotice.vue2.mjs";
+import './OCookieNotice.css';
+import './OCookieNotice2.css';
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const _OCookieNotice = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f4e92a4b"]]);
+export {
+  _OCookieNotice as default
+};