@dative-gpi/foundation-shared-components 1.0.194 → 1.1.0-fix01

package/components/FSButton.vue

@@ -1,6 +1,7 @@
 <template>
-  <FSClickable
+  <FSCard
     v-if="$props.variant !== 'icon'"
+    :clickable="true"
     :disabled="$props.disabled"
     :padding="padding"
     :variant="$props.variant"
@@ -8,7 +9,6 @@
     :load="$props.load"
     :href="$props.href"
     :to="$props.to"
-    :style="style"
     @click.stop="onClick"
     v-bind="$attrs"
   >
@@ -87,93 +87,62 @@
         </FSIcon>
       </slot>
     </FSCol>
-  </FSClickable>
-  <FSRow
+  </FSCard>
+  <FSRouterLink
     v-else
-    width="hug"
+    :to="$props.to"
+    :href="$props.href"
     :class="iconClasses"
-    :style="style"
     @click.stop="onClick"
-    v-bind="$attrs"
   >
-    <template
-      v-if="$props.load"
-    >
-      <v-progress-circular
-        class="fs-button-load"
-        width="2"
-        size="20"
-        :indeterminate="true"
-        :color="loadColor"
-      />
-    </template>
-    <template
-      v-else-if="$props.href"
+    <FSRow
+      width="hug"
+      align="center-left"
+      v-bind="$attrs"
     >
-      <a
-        :href="$props.href"
+      <template
+        v-if="$props.load"
       >
-        <FSIcon
-          v-if="$props.icon"
-          :size="$props.iconSize"
-        >
-          {{ $props.icon }}
-        </FSIcon>
-        <FSSpan
-          v-if="$props.label"
-        >
-          {{ $props.label }}
-        </FSSpan>
-      </a>
-    </template>
-    <template
-      v-else-if="$props.to"
-    >
-      <FSRouterLink
-        :to="$props.to"
+        <v-progress-circular
+          class="fs-button-load"
+          width="2"
+          size="20"
+          :indeterminate="true"
+          :color="loadColor"
+        />
+      </template>
+      <template
+        v-else
       >
         <FSIcon
           v-if="$props.icon"
+          :color="iconVariantColor"
           :size="$props.iconSize"
         >
           {{ $props.icon }}
         </FSIcon>
-        <FSSpan
+        <FSText
           v-if="$props.label"
+          :color="iconVariantColor"
         >
           {{ $props.label }}
-        </FSSpan>
-      </FSRouterLink>
-    </template>
-    <template
-      v-else
-    >
-      <FSIcon
-        v-if="$props.icon"
-        :size="$props.iconSize"
-      >
-        {{ $props.icon }}
-      </FSIcon>
-      <FSSpan
-        v-if="$props.label"
-      >
-        {{ $props.label }}
-      </FSSpan>
-    </template>
-  </FSRow>
+        </FSText>
+      </template>
+    </FSRow>
+  </FSRouterLink>
 </template>
 
 <script lang="ts">
-import { computed, defineComponent, type PropType, type StyleValue, useSlots } from "vue";
+import { computed, defineComponent, type PropType, useSlots } from "vue";
 import { type RouteLocation } from "vue-router";
 
 import { type ColorBase, ColorEnum } from "@dative-gpi/foundation-shared-components/models";
 import { useColors } from "@dative-gpi/foundation-shared-components/composables";
 
-import FSRouterLink from "./FSRouterLink.vue";
-import FSClickable from "./FSClickable.vue";
-import FSSpan from "./FSSpan.vue";
+import FSRouterLink from './FSRouterLink.vue';
+import FSText from "./FSText.vue";
 import FSIcon from "./FSIcon.vue";
+import FSCard from './FSCard.vue';
 import FSCol from "./FSCol.vue";
 import FSRow from "./FSRow.vue";
 
@@ -187,8 +156,8 @@ export default defineComponent({
   name: "FSButton",
   components: {
     FSRouterLink,
-    FSClickable,
-    FSSpan,
+    FSCard,
+    FSText,
     FSIcon,
     FSCol,
     FSRow
@@ -265,32 +234,17 @@ export default defineComponent({
     const { getColors } = useColors();
 
     const colors = computed(() => getColors(props.color));
-    const lights = getColors(ColorEnum.Light);
     const darks = getColors(ColorEnum.Dark);
     const slots = useSlots();
 
-    const style = computed((): StyleValue => {
+    const iconVariantColor = computed((): string => {
       if (props.disabled) {
-        switch (props.variant) {
-          case "icon": return {
-            "--fs-button-color": lights.dark,
-          };
-        }
+        return ColorEnum.Light;
       }
-      switch (props.variant) {
-        case "icon": switch (props.color) {
-          case ColorEnum.Dark:
-          case ColorEnum.Light: return {
-            "--fs-button-color"      : darks.base,
-            "--fs-button-hover-color": darks.dark,
-          };
-          default: return {
-            "--fs-button-color"      : colors.value.base,
-            "--fs-button-hover-color": colors.value.dark,
-          };
-        }
+      if (props.color === ColorEnum.Light) {
+        return ColorEnum.Dark;
       }
-      return {};
+      return props.color;
     });
 
     const iconClasses = computed((): string[] => {
@@ -337,11 +291,11 @@ export default defineComponent({
     };
 
     return {
-      iconClasses,
-      loadColor,
       colors,
-      style,
       padding,
+      loadColor,
+      iconClasses,
+      iconVariantColor,
       onClick
     };
   }

package/components/FSCard.vue

@@ -1,142 +1,191 @@
 <template>
-  <div
-    :class="classes"
+  <FSRouterLink
     :style="style"
+    :to="$props.to"
+    :href="$props.href"
+    :type="actualWrapperType"
+    :passive="actualClickable ? false : true"
+    :class="['fs-card-wrapper', $props.class]"
+    v-on="wrapperListeners"
   >
-    <slot>
-      <FSCol
-        :gap="$props.gap"
-      >
-        <FSRow
-          v-if="$slots.header"
-        >
-          <slot
-            name="header"
-          />
-        </FSRow>
-        <FSRow
-          v-if="$slots.body"
-        >
-          <slot
-            name="body"
-          />
-        </FSRow>
-        <FSRow
-          v-if="$slots.footer"
-        >
-          <slot
-            name="footer"
-          />
-        </FSRow>
-      </FSCol>
-    </slot>
-    <FSRow
-      v-if="$slots['top-right']"
-      class="fs-card-top-right"
+    <div
+      :class="classes"
     >
       <slot
-        name="top-right"
+        name="default"
+        v-bind="{ contentVariant }"
+      />
+      <v-progress-circular
+        v-if="$props.load"
+        class="fs-card-load__spinner"
+        width="2"
+        size="24"
+        :indeterminate="true"
+        :color="loadColor"
       />
-    </FSRow>
-  </div>
+      <FSRow
+        v-if="$slots['top-right'] && !$props.load"
+        class="fs-card-top-right"
+      >
+        <slot
+          name="top-right"
+        />
+      </FSRow>
+    </div>
+  </FSRouterLink>
 </template>
 
 <script lang="ts">
-import { computed, defineComponent, type PropType, type StyleValue } from "vue";
+import { computed, defineComponent, ref, type PropType, type StyleValue } from "vue";
+import { type RouteLocation } from "vue-router";
 
-import { type ColorBase, ColorEnum } from "@dative-gpi/foundation-shared-components/models";
-import { useColors } from "@dative-gpi/foundation-shared-components/composables";
 import { sizeToVar } from "@dative-gpi/foundation-shared-components/utils";
+import { useColors } from "@dative-gpi/foundation-shared-components/composables";
+import { type CardVariant, type ColorBase, ColorEnum, CardVariants, type ColorBaseVariations } from "@dative-gpi/foundation-shared-components/models";
 
-import FSCol from "./FSCol.vue";
 import FSRow from "./FSRow.vue";
+import FSRouterLink from "./FSRouterLink.vue";
 
 export default defineComponent({
   name: "FSCard",
   components: {
-    FSCol,
+    FSRouterLink,
     FSRow
   },
   props: {
     height: {
       type: [Array, String, Number] as PropType<string[] | number[] | string | number | null>,
-      required: false,
       default: null
     },
     width: {
       type: [Array, String, Number] as PropType<string[] | number[] | string | number | null>,
-      required: false,
       default: null
     },
     maxWidth: {
       type: [Array, String, Number] as PropType<string[] | number[] | string | number | null>,
-      required: false,
       default: null
     },
     padding: {
       type: [Array, String, Number] as PropType<string[] | number[] | string | number | null>,
-      required: false,
       default: "0"
     },
-    gap: {
-      type: [Array, String, Number] as PropType<string[] | number[] | string | number | null>,
+    class: {
+      type: [String, Array] as PropType<string | string[] | null>,
+      default: null
+    },
+    to: {
+      type: Object as PropType<RouteLocation | null>,
+      default: null
+    },
+    href: {
+      type: String as PropType<string | null>,
+      default: null
+    },
+    onClick: {
+      type: Function as PropType<(event: MouseEvent) => void | null>,
       required: false,
-      default: "8px"
+      default: null
     },
     variant: {
-      type: String as PropType<"background" | "standard" | "full" | "gradient">,
+      type: String as PropType<CardVariant>,
       required: false,
-      default: "background"
+      default: CardVariants.Background
+    },
+    clickable: {
+      type: Boolean as PropType<boolean | null>,
+      default: null
     },
     color: {
       type: [Array, String] as PropType<ColorBase | ColorBase[]>,
-      required: false,
       default: ColorEnum.Background
     },
     border: {
       type: Boolean,
-      required: false,
       default: true
     },
     borderRadius: {
       type: [String, Number],
-      required: false,
       default: "4px"
     },
     borderStyle: {
       type: String as PropType<"solid" | "dashed" | "dotted" | "double" | "groove" | "ridge" | "inset" | "outset" | "none">,
-      required: false,
       default: "solid"
     },
     borderColor: {
       type: [Array, String] as PropType<ColorBase | null | string>,
-      required: false,
       default: null
     },
     elevation: {
       type: Boolean,
-      required: false,
       default: false
     },
     topRightPadding: {
       type: [String, Number],
-      required: false,
       default: "4px"
+    },
+    type: {
+      type: String as PropType<"button" | "submit" | "reset" | null>,
+      default: null
+    },
+    load: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    disableHoverStyle: {
+      type: Boolean,
+      default: false
     }
   },
-  setup(props) {
+  setup(props, { emit }) {
     const { getColors, getGradients } = useColors();
 
+    const active = ref(false);
+    const hover = ref(false);
+
+    const backgrounds = getColors(ColorEnum.Background);
+    const lights = getColors(ColorEnum.Light);
+
     const colors = computed(() => {
       if (Array.isArray(props.color)) {
         return getColors(props.color[0]);
       }
       return getColors(props.color);
     });
+
     const gradients = computed(() => getGradients(props.color, 135));
-    const backgrounds = getColors(ColorEnum.Background);
-    const lights = getColors(ColorEnum.Light);
-    const darks = getColors(ColorEnum.Dark);
+
+    const actualClickable = computed((): boolean => {
+      if (props.clickable === false || props.disabled) {
+        return false;
+      }
+      return props.clickable || !!props.to || !!props.href || !!props.onClick;
+    });
+
+    const actualWrapperType = computed(() => {
+      if (props.type) {
+        return props.type;
+      }
+      return "button";
+    });
+
+    const contentVariant = computed((): ColorBaseVariations => {
+      if (active.value) {
+        return "darkContrast";
+      }
+      if (hover.value) {
+        return "baseContrast";
+      }
+      switch (props.variant) {
+        case "standard"  : return "lightContrast";
+        case "background": return "base";
+        case "full"      : return "baseContrast";
+      }
+      return "base";
+    });
 
     const borderColor = computed((): ColorBase => {
       if (props.borderColor) {
@@ -159,59 +208,76 @@ export default defineComponent({
       }
     });
 
+    const loadColor = computed((): string => {
+      return colors.value[contentVariant.value] ?? colors.value.baseContrast!;
+    });
+
     const style = computed((): StyleValue => {
+      const baseStyle = {
+        "--fs-card-border-size"     : props.border ? "1px" : "0",
+        "--fs-card-border-style"    : props.borderStyle,
+        "--fs-card-border-radius"   : sizeToVar(props.borderRadius),
+        "--fs-card-padding"         : sizeToVar(props.padding),
+        "--fs-card-height"          : sizeToVar(props.height),
+        "--fs-card-width"           : sizeToVar(props.width),
+        "--fs-card-max-width"       : sizeToVar(props.maxWidth, "unset"),
+        "--fs-card-top-right-padding": sizeToVar(props.topRightPadding)
+      };
+      if (props.disabled) {
+        return {
+          ...baseStyle,
+          "--fs-card-background-color": lights.light,
+          "--fs-card-border-color"    : lights.dark,
+          "--fs-card-color"           : props.clickable ? lights.dark : lights.lightContrast!
+        };
+      }
+      
       switch (props.variant) {
         case "background": return {
-          "--fs-card-border-size"     : props.border ? "1px" : "0",
-          "--fs-card-border-style"    : props.borderStyle,
-          "--fs-card-border-radius"   : sizeToVar(props.borderRadius),
-          "--fs-card-padding"         : sizeToVar(props.padding),
-          "--fs-card-height"          : sizeToVar(props.height),
-          "--fs-card-width"           : sizeToVar(props.width),
-          "--fs-card-max-width"       : sizeToVar(props.maxWidth, "unset"),
+          ...baseStyle,
           "--fs-card-background-color": backgrounds.base,
           "--fs-card-border-color"    : borderColor.value,
-          "--fs-card-color"           : darks.base,
-          "--fs-card-top-right-padding": sizeToVar(props.topRightPadding)
+          "--fs-card-color"           : backgrounds.baseContrast!,
+          "--fs-card-hover-background-color" : colors.value.base,
+          "--fs-card-hover-border-color"     : colors.value.baseContrast!,
+          "--fs-card-hover-color"            : colors.value.baseContrast!
         }
-        case "standard": return {
-          "--fs-card-border-size"     : props.border ? "1px" : "0",
-          "--fs-card-border-style"    : props.borderStyle,
-          "--fs-card-border-radius"   : sizeToVar(props.borderRadius),
-          "--fs-card-padding"         : sizeToVar(props.padding),
-          "--fs-card-height"          : sizeToVar(props.height),
-          "--fs-card-width"           : sizeToVar(props.width),
-          "--fs-card-max-width"       : sizeToVar(props.maxWidth, "unset"),
-          "--fs-card-background-color": colors.value.light,
-          "--fs-card-border-color"    : borderColor.value,
-          "--fs-card-color"           : colors.value.lightContrast!,
-          "--fs-card-top-right-padding": sizeToVar(props.topRightPadding)
+        case "standard": {
+          if (actualClickable.value && !Array.isArray(props.color) && [ColorEnum.Light, ColorEnum.Dark].includes(props.color as ColorEnum)) {
+            return {
+              ...baseStyle,
+              "--fs-card-background-color": backgrounds.base,
+              "--fs-card-border-color"    : lights.dark,
+              "--fs-card-color"           : backgrounds.baseContrast!,
+              "--fs-card-hover-background-color" : lights.base,
+              "--fs-card-hover-border-color"     : lights.dark,
+              "--fs-card-hover-color"            : lights.baseContrast!
+            };
+          }
+          return {
+            ...baseStyle,
+            "--fs-card-background-color": colors.value.light,
+            "--fs-card-border-color"    : borderColor.value,
+            "--fs-card-color"           : colors.value.lightContrast!,
+            "--fs-card-hover-background-color" : colors.value.base,
+            "--fs-card-hover-border-color"     : colors.value.base,
+            "--fs-card-hover-color"            : colors.value.baseContrast!
+          };
         }
         case "full": return {
-          "--fs-card-border-size"     : props.border ? "1px" : "0",
-          "--fs-card-border-style"    : props.borderStyle,
-          "--fs-card-border-radius"   : sizeToVar(props.borderRadius),
-          "--fs-card-padding"         : sizeToVar(props.padding),
-          "--fs-card-height"          : sizeToVar(props.height),
-          "--fs-card-width"           : sizeToVar(props.width),
-          "--fs-card-max-width"       : sizeToVar(props.maxWidth, "unset"),
+          ...baseStyle,
           "--fs-card-background-color": colors.value.base,
           "--fs-card-border-color"    : borderColor.value,
           "--fs-card-color"           : colors.value.baseContrast!,
-          "--fs-card-top-right-padding": sizeToVar(props.topRightPadding)
+          "--fs-card-hover-background-color" : colors.value.base,
+          "--fs-card-hover-border-color"     : colors.value.base,
+          "--fs-card-hover-color"            : colors.value.baseContrast!
         }
         case "gradient": return {
-          "--fs-card-border-size"     : props.border ? "1px" : "0",
-          "--fs-card-border-style"    : props.borderStyle,
-          "--fs-card-border-radius"   : sizeToVar(props.borderRadius),
-          "--fs-card-padding"         : sizeToVar(props.padding),
-          "--fs-card-height"          : sizeToVar(props.height),
-          "--fs-card-width"           : sizeToVar(props.width),
-          "--fs-card-max-width"       : sizeToVar(props.maxWidth, "unset"),
+          ...baseStyle,
           "--fs-card-background-color": gradients.value.base,
           "--fs-card-border-color"    : borderColor.value,
-          "--fs-card-color"           : colors.value.lightContrast!,
-          "--fs-card-top-right-padding": sizeToVar(props.topRightPadding)
+          "--fs-card-color"           : colors.value.lightContrast!
         }
       }
     });
@@ -224,21 +290,63 @@ export default defineComponent({
           break;
         case "background":
           classNames.push("fs-card-background");
-          classNames.push("fs-card-clickable");
           break;
         default:
           classNames.push("fs-card-background");
           break;
       }
+
+      if (actualClickable.value) {
+        classNames.push("fs-card-clickable");
+      }
+      if (props.disableHoverStyle) {
+        classNames.push("fs-card-disable-hover-style");
+      }
+      if (props.disabled) {
+        classNames.push("fs-card-disabled");
+      }
+      if (props.load) {
+        classNames.push("fs-card-load");
+      }
       if (props.elevation) {
         classNames.push("fs-card-elevation");
       }
+      
       return classNames;
     });
+    
+    const wrapperListeners = computed(() => {
+      if (actualClickable.value && !props.disabled) {
+        return {
+          mouseover: () => { hover.value = true },
+          mouseleave: () => { hover.value = false },
+          mousedown: () => { active.value = true },
+          mouseup: () => { active.value = false },
+          "click": onClick
+        };
+      }
+      return {};
+    });
+
+    const onClick = (event: MouseEvent) => {
+      if (!actualClickable.value || props.disabled || props.load || props.href || props.to) {
+        return;
+      }
+      emit("click", event);
+    };
 
     return {
+      actualWrapperType,
+      actualClickable,
+      contentVariant,
+      FSRouterLink,
+      loadColor,
       classes,
-      style
+      active,
+      hover,
+      style,
+      onClick,
+      wrapperListeners
     };
   }
 });