@vc-shell/framework 1.1.1 → 1.1.2

package/dist/assets/ui-indicators-mIQeEqha.js

@@ -0,0 +1,199 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, createElementVNode, renderSlot, createCommentVNode, normalizeStyle, toDisplayString, Fragment, renderList, createBlock, unref } from 'vue';
+import { _ as _sfc_main$5 } from './ui-media-WWYrwmZw.js';
+import './ui-controls-nmDJYLmC.js';
+import './ui-layout-v2XBQky3.js';
+import './ui-helpers-CF-EUlOg.js';
+import './ui-navigation-BtHa6ovW.js';
+import './core-composables-DYxpIWyY.js';
+import './ui-app-D31Pr1WY.js';
+import 'vee-validate';
+import './ui-content-B7SxH8y9.js';
+import './ui-form-Cs5ooOo7.js';
+import './ui-form-fields-DFQi31jT.js';
+import './shared-composables-v9NkNuAe.js';
+import './core-plugins-wv2bDZ0l.js';
+import 'vue-router';
+import './shared-components-CfAt2hC6.js';
+import './shared-modules-CDP-H5ZB.js';
+import './ui-data-Ci3b1ye0.js';
+import './ui-media-advanced-T8ibi153.js';
+
+const _hoisted_1$3 = { class: "vc-badge__content" };
+const _hoisted_2$1 = {
+  key: 0,
+  class: "vc-badge__text"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "vc-badge",
+  props: {
+    active: { type: Boolean },
+    disabled: { type: Boolean },
+    clickable: { type: Boolean },
+    content: {},
+    size: { default: "m" },
+    isDot: { type: Boolean, default: false },
+    variant: { default: "primary" },
+    customPosition: { type: Boolean, default: false },
+    top: { default: void 0 },
+    right: { default: void 0 }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function onClick() {
+      if (props.clickable && !props.disabled) {
+        emit("click");
+      }
+    }
+    const customPositionStyle = computed(() => {
+      if (!props.customPosition) return {};
+      return {
+        top: props.top,
+        right: props.right
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref: "badgeContainer",
+        class: normalizeClass(["vc-badge", {
+          "vc-badge--small": _ctx.size === "s",
+          "vc-badge--medium": _ctx.size === "m"
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1$3, [
+          renderSlot(_ctx.$slots, "default"),
+          typeof _ctx.content !== "undefined" ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            ref: "badge",
+            class: normalizeClass(["vc-badge__badge", [
+              `vc-badge__badge--${_ctx.variant}`,
+              {
+                "vc-badge__badge--active": _ctx.active,
+                "vc-badge__badge--clickable": _ctx.clickable,
+                "vc-badge__badge--disabled": _ctx.disabled,
+                "vc-badge__badge--content-long": String(_ctx.content).length > 1,
+                "vc-badge__badge--content-very-long": String(_ctx.content).length > 2,
+                "vc-badge__badge--dot": _ctx.isDot,
+                "vc-badge__badge--custom-position": _ctx.customPosition
+              }
+            ]]),
+            style: normalizeStyle(customPositionStyle.value),
+            onClick
+          }, [
+            !_ctx.isDot ? (openBlock(), createElementBlock("span", _hoisted_2$1, toDisplayString(_ctx.content), 1)) : createCommentVNode("", true)
+          ], 6)) : createCommentVNode("", true)
+        ])
+      ], 2);
+    };
+  }
+});
+
+const _hoisted_1$2 = { class: "vc-loading-overlay__content" };
+const _hoisted_2 = { class: "vc-loading-overlay__markers" };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "vc-loading",
+  props: {
+    active: { type: Boolean }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-loading-overlay", {
+          "vc-loading-overlay--active": _ctx.active
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1$2, [
+          _cache[0] || (_cache[0] = createElementVNode("span", { class: "vc-loading-overlay__main-marker" }, null, -1)),
+          createElementVNode("div", _hoisted_2, [
+            (openBlock(), createElementBlock(Fragment, null, renderList(3, (item) => {
+              return createElementVNode("span", {
+                key: `marker_${item}`,
+                class: "vc-loading-overlay__marker"
+              });
+            }), 64))
+          ])
+        ])
+      ], 2);
+    };
+  }
+});
+
+const VcLoading = _sfc_main$3;
+
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "vc-progress",
+  props: {
+    value: { default: 0 },
+    variant: { default: "default" }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-progress", {
+          "vc-progress--striped": _ctx.variant === "striped"
+        }])
+      }, [
+        createElementVNode("div", {
+          class: "vc-progress__value",
+          style: normalizeStyle(`width: ${_ctx.value}%`)
+        }, null, 4)
+      ], 2);
+    };
+  }
+});
+
+const VcProgress = _sfc_main$2;
+
+const _hoisted_1$1 = { class: "vc-status__content" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "vc-status",
+  props: {
+    variant: { default: "info" },
+    outline: { type: Boolean, default: false },
+    extend: { type: Boolean },
+    dot: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-status", [
+          `vc-status_${_ctx.variant}`,
+          {
+            "vc-status_extended": _ctx.extend,
+            "vc-status_dot": _ctx.dot
+          }
+        ]])
+      }, [
+        createElementVNode("div", _hoisted_1$1, [
+          renderSlot(_ctx.$slots, "default")
+        ])
+      ], 2);
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vc-status-icon" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "vc-status-icon",
+  props: {
+    status: { type: Boolean }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        _ctx.status ? (openBlock(), createBlock(unref(_sfc_main$5), {
+          key: 0,
+          icon: "material-check_circle",
+          class: "vc-status-icon__icon vc-status-icon__icon--success"
+        })) : (openBlock(), createBlock(unref(_sfc_main$5), {
+          key: 1,
+          icon: "material-cancel",
+          class: "vc-status-icon__icon vc-status-icon__icon--info"
+        }))
+      ]);
+    };
+  }
+});
+
+export { VcLoading as V, _sfc_main$4 as _, VcProgress as a, _sfc_main$1 as b, _sfc_main as c };

package/dist/assets/ui-layout-v2XBQky3.js

@@ -0,0 +1,320 @@
+import { defineComponent, ref, watch, createElementBlock, openBlock, normalizeClass, createCommentVNode, createVNode, renderSlot, createBlock, createElementVNode, unref, toDisplayString, Transition, withCtx, withDirectives, vShow, normalizeStyle, shallowRef, inject, computed, onMounted, getCurrentInstance, resolveComponent } from 'vue';
+import { _ as _sfc_main$5 } from './ui-media-WWYrwmZw.js';
+import { u as useWidgets } from './ui-navigation-BtHa6ovW.js';
+import './core-composables-DYxpIWyY.js';
+import './ui-app-D31Pr1WY.js';
+import 'vee-validate';
+
+const _hoisted_1$3 = { class: "vc-card__header-content" };
+const _hoisted_2$2 = { class: "vc-card__title" };
+const _hoisted_3$2 = {
+  key: 0,
+  class: "vc-card__actions"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "vc-card",
+  props: {
+    header: {},
+    icon: {},
+    isCollapsable: { type: Boolean },
+    isCollapsed: { type: Boolean },
+    fill: { type: Boolean },
+    variant: { default: "default" }
+  },
+  emits: ["header:click", "state:collapsed"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isCollapsedInternal = ref();
+    function onHeaderClick() {
+      if (props.isCollapsable) {
+        isCollapsedInternal.value = !isCollapsedInternal.value;
+        emit("state:collapsed", isCollapsedInternal.value);
+      }
+      emit("header:click");
+    }
+    watch(
+      () => props.isCollapsed,
+      (value) => {
+        isCollapsedInternal.value = value;
+      },
+      {
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-card", [{ "vc-card_collapsable": _ctx.isCollapsable }, `vc-card_${_ctx.variant}`]])
+      }, [
+        _ctx.header ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "vc-card__header",
+          onClick: onHeaderClick
+        }, [
+          renderSlot(_ctx.$slots, "header", {}, () => [
+            createElementVNode("div", _hoisted_1$3, [
+              _ctx.icon ? (openBlock(), createBlock(unref(_sfc_main$5), {
+                key: 0,
+                class: "vc-card__icon",
+                icon: _ctx.icon,
+                size: "xl"
+              }, null, 8, ["icon"])) : createCommentVNode("", true),
+              createElementVNode("div", _hoisted_2$2, toDisplayString(_ctx.header), 1)
+            ])
+          ]),
+          _ctx.$slots["actions"] ? (openBlock(), createElementBlock("div", _hoisted_3$2, [
+            renderSlot(_ctx.$slots, "actions")
+          ])) : createCommentVNode("", true),
+          _ctx.isCollapsable ? (openBlock(), createBlock(unref(_sfc_main$5), {
+            key: 1,
+            class: "vc-card__collapse",
+            icon: `material-keyboard_arrow_${isCollapsedInternal.value ? "down" : "up"}`,
+            size: "s"
+          }, null, 8, ["icon"])) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true),
+        createVNode(Transition, { name: "fade" }, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", {
+              class: normalizeClass([{ "tw-flex": _ctx.fill }, "vc-card__body"])
+            }, [
+              renderSlot(_ctx.$slots, "default")
+            ], 2), [
+              [vShow, !isCollapsedInternal.value]
+            ])
+          ]),
+          _: 3
+        })
+      ], 2);
+    };
+  }
+});
+
+const VcCard = _sfc_main$4;
+
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "vc-col",
+  props: {
+    size: { default: 1 }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "vc-col",
+        style: normalizeStyle({ flexGrow: _ctx.size })
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 4);
+    };
+  }
+});
+
+const _hoisted_1$2 = { class: "vc-container__status" };
+const _hoisted_2$1 = { key: 0 };
+const _hoisted_3$1 = { key: 1 };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "vc-container",
+  props: {
+    shadow: { type: Boolean },
+    noPadding: { type: Boolean },
+    usePtr: { type: Boolean }
+  },
+  emits: ["scroll:ptr", "scroll"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const component = ref();
+    const scroll = ref(false);
+    const pullDist = ref(60);
+    const touchDiff = shallowRef(0);
+    let touchstartY = 0;
+    const refreshing = shallowRef(false);
+    const goingUp = shallowRef(false);
+    const touching = shallowRef(false);
+    const isMobile = inject("isMobile");
+    const topOffset = computed(() => Math.max(0, Math.min(pullDist.value, touchDiff.value)));
+    const canRefresh = computed(() => touchDiff.value >= pullDist.value && !refreshing.value);
+    const scrollTop = () => {
+      if (component.value) {
+        component.value.scroll(0, 0);
+      }
+    };
+    function onTouchstart(e) {
+      if (!isMobile.value || refreshing.value || !props.usePtr || component.value && component.value.scrollTop > 0)
+        return;
+      touching.value = true;
+      touchstartY = "clientY" in e ? e.clientY : e.touches[0].clientY;
+    }
+    function onTouchmove(e) {
+      if (refreshing.value || !touching.value) return;
+      const touchY = "clientY" in e ? e.clientY : e.touches[0].clientY;
+      if (component.value && component.value.scrollTop === 0) {
+        touchDiff.value = touchY - touchstartY;
+      }
+    }
+    function onTouchend() {
+      if (refreshing.value) return;
+      touching.value = false;
+      if (canRefresh.value) {
+        touchDiff.value = 0;
+        refreshing.value = true;
+        emit("scroll:ptr");
+        refreshing.value = false;
+      } else {
+        touchDiff.value = 0;
+      }
+    }
+    function onScroll(e) {
+      emit("scroll", e);
+    }
+    onMounted(() => {
+      const observer = new ResizeObserver(() => {
+        scroll.value = component.value && component.value.clientHeight < component.value.scrollHeight;
+      });
+      if (component.value) {
+        observer.observe(component.value);
+      }
+    });
+    watch(topOffset, (newVal, oldVal) => {
+      goingUp.value = newVal < oldVal;
+    });
+    __expose({
+      scrollTop,
+      component
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "vc-container",
+          {
+            "vc-container_shadow": _ctx.shadow && scroll.value,
+            "vc-container_nopadding": _ctx.noPadding
+          }
+        ]),
+        onTouchstart,
+        onTouchmove,
+        onTouchend
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(["vc-container__overscroll", { "vc-container__overscroll_touching": touching.value }]),
+          style: normalizeStyle({
+            top: -1 * pullDist.value + topOffset.value + "px",
+            height: pullDist.value + "px"
+          })
+        }, [
+          createElementVNode("div", _hoisted_1$2, [
+            createVNode(unref(_sfc_main$5), {
+              icon: canRefresh.value || goingUp.value ? "material-arrow_upward" : "material-arrow_downward",
+              class: "vc-container__overscroll-icon"
+            }, null, 8, ["icon"]),
+            !(canRefresh.value || goingUp.value) ? (openBlock(), createElementBlock("span", _hoisted_2$1, toDisplayString(_ctx.$t("COMPONENTS.ATOMS.VC_CONTAINER.PULL_TO_REFRESH")), 1)) : (openBlock(), createElementBlock("span", _hoisted_3$1, toDisplayString(_ctx.$t("COMPONENTS.ATOMS.VC_CONTAINER.REFRESHING")), 1))
+          ])
+        ], 6),
+        createElementVNode("div", {
+          ref_key: "component",
+          ref: component,
+          class: normalizeClass(["vc-container__inner", {
+            "vc-container__inner_touching": touching.value
+          }]),
+          style: normalizeStyle({ top: topOffset.value + "px" }),
+          onScroll
+        }, [
+          renderSlot(_ctx.$slots, "default")
+        ], 38)
+      ], 34);
+    };
+  }
+});
+
+const VcContainer = _sfc_main$2;
+
+const _hoisted_1$1 = { class: "vc-row" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "vc-row",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+
+const _hoisted_1 = ["data-widget-id", "data-widget-name"];
+const _hoisted_2 = { class: "vc-widget__icon-container" };
+const _hoisted_3 = {
+  key: 0,
+  class: "vc-widget__content"
+};
+const _hoisted_4 = { class: "vc-widget__title" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "vc-widget",
+  props: {
+    icon: {},
+    title: {},
+    value: {},
+    disabled: { type: Boolean },
+    isExpanded: { type: Boolean },
+    horizontal: { type: Boolean }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const instance = getCurrentInstance();
+    const widgetService = useWidgets();
+    const widgetName = instance?.parent?.type.__name;
+    function onClick() {
+      if (!props.disabled) {
+        if (widgetName && instance?.parent?.exposed) {
+          widgetService.setActiveWidget(instance?.parent?.exposed);
+        }
+        emit("click");
+      }
+    }
+    const truncateCount = computed(() => {
+      if (typeof props.value === "string" && parseInt(props.value) > 99 || typeof props.value === "number" && props.value > 99) {
+        return "99+";
+      } else {
+        return props.value;
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_VcBadge = resolveComponent("VcBadge");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["vc-widget", [
+          { "vc-widget--expanded": _ctx.isExpanded },
+          { "vc-widget--collapsed": !_ctx.isExpanded },
+          { "vc-widget--disabled": _ctx.disabled },
+          { "vc-widget--horizontal": _ctx.horizontal }
+        ]]),
+        "data-widget-id": unref(widgetName),
+        "data-widget-name": _ctx.title,
+        onClick
+      }, [
+        createVNode(_component_VcBadge, {
+          content: truncateCount.value,
+          size: "s"
+        }, {
+          default: withCtx(() => [
+            createElementVNode("div", _hoisted_2, [
+              _ctx.icon ? (openBlock(), createBlock(unref(_sfc_main$5), {
+                key: 0,
+                class: "vc-widget__icon",
+                icon: _ctx.icon,
+                size: "m"
+              }, null, 8, ["icon"])) : createCommentVNode("", true)
+            ])
+          ]),
+          _: 1
+        }, 8, ["content"]),
+        _ctx.title ? (openBlock(), createElementBlock("div", _hoisted_3, [
+          createElementVNode("div", _hoisted_4, toDisplayString(_ctx.title), 1)
+        ])) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+
+const VcWidget = _sfc_main;
+
+export { VcCard as V, _sfc_main$3 as _, VcContainer as a, _sfc_main$1 as b, VcWidget as c, _sfc_main$2 as d };