windly-ui 1.0.2 → 1.0.4

package/dist/runtime/components/Tooltip.vue.d.ts

@@ -0,0 +1,63 @@
+type TooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: () => TooltipPlacement;
+        default: string;
+        validator: (v: string) => any;
+    };
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    textColor: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: () => TooltipPlacement;
+        default: string;
+        validator: (v: string) => any;
+    };
+    arrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    textColor: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    textColor: string;
+    color: string;
+    placement: TooltipPlacement;
+    arrow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/uiProps.d.ts

@@ -0,0 +1,38 @@
+export declare const uiProps: {
+    readonly contentClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly contentStyle: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly textColor: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly disable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly color: {
+        readonly type: StringConstructor;
+        readonly default: "blue-900";
+    };
+    readonly rounded: {
+        readonly type: StringConstructor;
+        readonly default: "md";
+    };
+    readonly size: {
+        readonly type: StringConstructor;
+        readonly default: "md";
+    };
+    readonly iconSize: {
+        readonly type: StringConstructor;
+        readonly default: "lg";
+    };
+};

package/dist/runtime/components/uiProps.js

@@ -0,0 +1,11 @@
+export const uiProps = {
+  contentClass: { type: String, default: "" },
+  contentStyle: { type: String, default: "" },
+  textColor: { type: String, default: "" },
+  disable: { type: Boolean, default: false },
+  loading: { type: Boolean, default: false },
+  color: { type: String, default: "blue-900" },
+  rounded: { type: String, default: "md" },
+  size: { type: String, default: "md" },
+  iconSize: { type: String, default: "lg" }
+};

package/dist/runtime/components/useUiClasses.d.ts

@@ -0,0 +1,43 @@
+import type { ExtractPropTypes } from "vue";
+import { uiProps } from "./uiProps.js";
+type UiProps = ExtractPropTypes<typeof uiProps>;
+export declare function useUiClasses(props: Partial<UiProps>): {
+    contentClass: import("vue").Ref<string, string>;
+    contentStyle: import("vue").Ref<string, string>;
+    textColor: import("vue").Ref<string, string>;
+    disable: import("vue").Ref<boolean, boolean>;
+    loading: import("vue").Ref<boolean, boolean>;
+    color: import("vue").Ref<string, string>;
+    rounded: import("vue").Ref<string, string>;
+    size: import("vue").Ref<string, string>;
+    iconSize: import("vue").Ref<string, string>;
+    roundedClass: {
+        none: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        full: string;
+    };
+    sizeClass: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    iconSizeClasses: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    colorClass: import("vue").ComputedRef<string>;
+    computedContentClass: import("vue").ComputedRef<string>;
+    isColorDark: (color: string) => boolean;
+    isHex: (color: string) => boolean;
+    isTailwindColor: (color: string) => boolean;
+    shadeTailwind: (color: string, delta?: number) => string;
+    shadeHex: (hex: string, amount?: number) => string;
+};
+export {};

package/dist/runtime/components/useUiClasses.js

@@ -0,0 +1,124 @@
+import { computed, toRefs } from "vue";
+export function useUiClasses(props) {
+  const safeProps = {
+    contentClass: "",
+    contentStyle: "",
+    textColor: "",
+    disable: false,
+    loading: false,
+    color: "",
+    rounded: "md",
+    size: "md",
+    iconSize: "md",
+    ...props
+  };
+  const {
+    contentClass,
+    contentStyle,
+    textColor,
+    disable,
+    loading,
+    color,
+    rounded,
+    size,
+    iconSize
+  } = toRefs(safeProps);
+  const roundedClass = {
+    none: "rounded-none",
+    xs: "rounded-xs",
+    sm: "rounded-sm",
+    md: "rounded",
+    lg: "rounded-lg",
+    xl: "rounded-xl",
+    full: "rounded-full"
+  };
+  const sizeClass = {
+    sm: "text-xs",
+    md: "text-base",
+    lg: "text-xl"
+  };
+  const iconSizeClasses = {
+    xs: "text-xs",
+    sm: "text-sm",
+    md: "text-base",
+    lg: "text-lg",
+    xl: "text-xl"
+  };
+  const colorClass = computed(() => {
+    if (!color.value) return "";
+    return color.value.includes("#") ? `[${color.value}]` : color.value;
+  });
+  const computedContentClass = computed(() => {
+    if (!contentClass.value) return "";
+    return contentClass.value.split(" ").map((cls) => cls.startsWith("!") ? cls : `!${cls}`).join(" ");
+  });
+  function isTailwindColorDark(color2) {
+    const match = color2.match(/-(\d{2,3})$/);
+    if (!match) return false;
+    return Number(match[1]) >= 400;
+  }
+  function isHexColorDark(hex) {
+    let c = hex.replace("#", "");
+    if (c.length === 3) {
+      c = c.split("").map((x) => x + x).join("");
+    }
+    const r = parseInt(c.substring(0, 2), 16);
+    const g = parseInt(c.substring(2, 4), 16);
+    const b = parseInt(c.substring(4, 6), 16);
+    const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+    return luminance < 140;
+  }
+  function isHex(color2) {
+    return /^#([0-9A-F]{3}){1,2}$/i.test(color2);
+  }
+  function isTailwindColor(color2) {
+    return /^[a-z]+-\d{2,3}$/.test(color2);
+  }
+  const isColorDark = (color2) => {
+    if (!color2) return false;
+    return color2.startsWith("#") ? isHexColorDark(color2) : isTailwindColorDark(color2);
+  };
+  function shadeTailwind(color2, delta = 100) {
+    const [name, shade] = color2.split("-");
+    const nextShade = Math.min(900, Math.max(100, Number(shade) + delta));
+    return `${name}-${nextShade}`;
+  }
+  function shadeHex(hex, amount = -10) {
+    let c = hex.substring(1);
+    if (c.length === 3) {
+      c = c.split("").map((x) => x + x).join("");
+    }
+    const num = parseInt(c, 16);
+    let r = num >> 16 & 255;
+    let g = num >> 8 & 255;
+    let b = num & 255;
+    r = Math.min(255, Math.max(0, r + amount));
+    g = Math.min(255, Math.max(0, g + amount));
+    b = Math.min(255, Math.max(0, b + amount));
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+  }
+  return {
+    // props
+    contentClass,
+    contentStyle,
+    textColor,
+    disable,
+    loading,
+    color,
+    rounded,
+    size,
+    iconSize,
+    // class maps
+    roundedClass,
+    sizeClass,
+    iconSizeClasses,
+    // computed
+    colorClass,
+    computedContentClass,
+    isColorDark,
+    isHex,
+    isTailwindColor,
+    shadeTailwind,
+    shadeHex
+  };
+}

package/dist/runtime/composables/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/composables/plugin.js

@@ -0,0 +1,3 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((nuxtApp) => {
+});

package/dist/runtime/tailwind-color.d.ts

@@ -0,0 +1,2 @@
+declare const tailwindColor: string[];
+export default tailwindColor;