vueless 0.0.473 → 0.0.475

package/adatper.locale/locales/en.d.ts

@@ -0,0 +1,289 @@
+declare namespace _default {
+    let USelect: {
+        listIsEmpty: string;
+        noDataToShow: string;
+        clear: string;
+        addMore: string;
+    };
+    let USwitch: {
+        inactive: string;
+        active: string;
+    };
+    let UInputFile: {
+        sizeError: string;
+        formatError: string;
+        noFile: string;
+        uploadFile: string;
+    };
+    let UDropdownList: {
+        noDataToShow: string;
+        add: string;
+    };
+    let UModalConfirm: {
+        confirm: string;
+        cancel: string;
+    };
+    let UTable: {
+        noData: string;
+    };
+    let UCalendar: {
+        weekdays: {
+            shorthand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            longhand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            userFormat: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+        };
+        months: {
+            shorthand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            longhand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            userFormat: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        timeLabel: string;
+        okLabel: string;
+    };
+    let UDatePicker: {
+        today: string;
+        yesterday: string;
+        tomorrow: string;
+        weekdays: {
+            shorthand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            longhand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            userFormat: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+        };
+        months: {
+            shorthand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            longhand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            userFormat: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        timeLabel: string;
+        okLabel: string;
+    };
+    let UDatePickerRange: {
+        ownRange: string;
+        week: string;
+        month: string;
+        quarter: string;
+        year: string;
+        dateFormatWithDot: string;
+        notCorrectMonthNumber: string;
+        notCorrectDayNumber: string;
+        fromDateGraterThanSecond: string;
+        toDateSmallerThanFirst: string;
+        weekdays: {
+            shorthand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            longhand: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+            userFormat: {
+                sunday: string;
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+            };
+        };
+        months: {
+            shorthand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            longhand: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+            userFormat: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+    };
+    let UDataList: {
+        edit: string;
+        delete: string;
+        emptyTitle: string;
+        emptyDescription: string;
+    };
+    let UNotify: {
+        success: {
+            default: string;
+        };
+        warning: {
+            default: string;
+        };
+        error: {
+            default: string;
+        };
+    };
+}
+export default _default;

package/adatper.locale/vue-i18n.d.ts

@@ -0,0 +1,9 @@
+export default function createVueI18nAdapter(i18n: any): {
+    name: string;
+    locale: any;
+    fallback: any;
+    messages: any;
+    t: (key: any, ...params: any[]) => any;
+    tm: any;
+    n: any;
+};

package/adatper.locale/vueless.d.ts

@@ -0,0 +1,11 @@
+export default function createVuelessAdapter(options: any): {
+    name: string;
+    locale: import("vue").ShallowRef<any>;
+    fallback: import("vue").ShallowRef<any>;
+    messages: import("vue").Ref<any, any>;
+    t: (key: any, ...params: any[]) => any;
+    tm: (key: any) => any;
+    n: (value: any, options: any) => string;
+};
+export function getObjectValueByPath(obj: any, path: any, fallback: any): any;
+export function getNestedValue(obj: any, path: any, fallback: any): any;

package/composables/useAutoPosition.d.ts

@@ -0,0 +1,15 @@
+export function useAutoPosition(anchorElement: any, targetElement: any, position: any, preferredPosition: any): {
+    isTop: import("vue").ComputedRef<boolean>;
+    isRight: import("vue").ComputedRef<boolean>;
+    isBottom: import("vue").ComputedRef<boolean>;
+    isLeft: import("vue").ComputedRef<boolean>;
+    adjustPositionY: () => void;
+    adjustPositionX: () => void;
+};
+export namespace POSITION {
+    let left: string;
+    let right: string;
+    let top: string;
+    let bottom: string;
+    let auto: string;
+}

package/composables/useBreakpoint.d.ts

@@ -0,0 +1,7 @@
+export default function useBreakpoint(): {
+    isLaptopBreakpoint: import("vue").ComputedRef<boolean>;
+    isTabletBreakpoint: import("vue").ComputedRef<boolean>;
+    isMobileBreakpoint: import("vue").ComputedRef<boolean>;
+    isPortableBreakpoint: import("vue").ComputedRef<boolean>;
+    elementSize: import("vue").ComputedRef<string>;
+};

package/composables/useBreakpoint.js

@@ -59,7 +59,7 @@ export default function useBreakpoint() {
   onBeforeUnmount(() => {
     if (isSSR) return;
 
-    window.removeEventListener("resize", resizeListener, { passive: true });
+    window.removeEventListener("resize", resizeListener);
   });
 
   watch(windowWidth, setBreakpoint, { immediate: true });

package/composables/useLocale.d.ts

@@ -0,0 +1,3 @@
+export function createLocale(options: any): any;
+export function useLocale(): any;
+export const LocaleSymbol: unique symbol;

package/composables/useMutationObserver.d.ts

@@ -0,0 +1,7 @@
+export function useMutationObserver(target: any, callBack: any, config?: {
+    childList: boolean;
+    attributes: boolean;
+    characterData: boolean;
+}): {
+    observer: MutationObserver;
+} | undefined;

package/composables/useUI.d.ts

@@ -0,0 +1,17 @@
+export default function useUI(defaultConfig: {} | undefined, propsConfigGetter: null | undefined, topLevelClassKey: any): {
+    config: import("vue").Ref<{}, {}>;
+    setColor: typeof setColor;
+    getColor: typeof getColor;
+    getAttrs: (configKey: string, options: Object) => Object;
+    getKeysAttrs: (mutatedProps?: {}, extendingKeys?: any[], keysToExtendConfig?: {}) => Object;
+    getExtendingKeysClasses: (extendingKeys: any[], mutatedProps?: Object) => Object;
+    isCVA: typeof isCVA;
+    isSystemKey: typeof isSystemKey;
+    hasSlotContent: typeof hasSlotContent;
+};
+import { setColor } from "../utils/utilUI.js";
+import { getColor } from "../utils/utilUI.js";
+declare function isCVA(config: Object | string): boolean;
+declare function isSystemKey(key: string): boolean;
+declare function hasSlotContent(slot: any, props?: {}): boolean;
+export {};

package/composablesTs/useAutoPosition.d.ts

@@ -0,0 +1,28 @@
+import type { Ref, ComputedRef } from "vue";
+interface PositionXY {
+    x: Position;
+    y: Position;
+}
+export declare enum Position {
+    Left = "left",
+    Right = "right",
+    Top = "top",
+    Bottom = "bottom",
+    Auto = "auto"
+}
+export declare const POSITION: {
+    left: string;
+    right: string;
+    top: string;
+    bottom: string;
+    auto: string;
+};
+export declare function useAutoPosition(anchorElement: Ref<HTMLElement | null>, targetElement: Ref<HTMLElement | null>, position: PositionXY | ComputedRef<PositionXY>, preferredPosition: PositionXY | ComputedRef<PositionXY>): {
+    isTop: ComputedRef<boolean>;
+    isRight: ComputedRef<boolean>;
+    isBottom: ComputedRef<boolean>;
+    isLeft: ComputedRef<boolean>;
+    adjustPositionY: () => void;
+    adjustPositionX: () => void;
+};
+export {};

package/composablesTs/useAutoPosition.ts

@@ -0,0 +1,115 @@
+import { computed, toValue, ref } from "vue";
+import { isSSR } from "../utils/utilHelper.js";
+
+import type { Ref, ComputedRef } from "vue";
+
+interface PositionXY {
+  x: Position;
+  y: Position;
+}
+
+export enum Position {
+  Left = "left",
+  Right = "right",
+  Top = "top",
+  Bottom = "bottom",
+  Auto = "auto",
+}
+
+// TODO: Remove after full TS migration, use enum instead.
+export const POSITION = {
+  left: "left",
+  right: "right",
+  top: "top",
+  bottom: "bottom",
+  auto: "auto",
+};
+
+export function useAutoPosition(
+  anchorElement: Ref<HTMLElement | null>,
+  targetElement: Ref<HTMLElement | null>,
+  position: PositionXY | ComputedRef<PositionXY>,
+  preferredPosition: PositionXY | ComputedRef<PositionXY>,
+) {
+  const localAnchorElement = computed(() => toValue(anchorElement));
+  const localTargetElement = computed(() => toValue(targetElement));
+  const localPosition = computed(() => toValue(position));
+  const localPreferredPosition = computed(() => toValue(preferredPosition));
+
+  const preferredOpenDirectionY = ref(localPreferredPosition.value?.y || Position.Bottom);
+  const preferredOpenDirectionX = ref(localPreferredPosition.value?.x || Position.Left);
+
+  const isTop = computed(() => {
+    if (localPosition.value.y !== Position.Auto) {
+      return localPosition.value.y === Position.Top;
+    }
+
+    return preferredOpenDirectionY.value === Position.Top;
+  });
+
+  const isLeft = computed(() => {
+    if (localPosition.value.x !== Position.Auto) {
+      return localPosition.value.x === Position.Left;
+    }
+
+    return preferredOpenDirectionX.value === Position.Left;
+  });
+
+  const isBottom = computed(() => {
+    if (localPosition.value.y !== Position.Auto) {
+      return localPosition.value.y === Position.Bottom;
+    }
+
+    return preferredOpenDirectionY.value === Position.Bottom;
+  });
+
+  const isRight = computed(() => {
+    if (localPosition.value.x !== Position.Auto) {
+      return localPosition.value.x === Position.Right;
+    }
+
+    return preferredOpenDirectionX.value === Position.Right;
+  });
+
+  function adjustPositionY(): void {
+    if (isSSR || !localAnchorElement.value || !localTargetElement.value) return;
+
+    const spaceAbove = localAnchorElement.value.getBoundingClientRect().top;
+    const spaceBelow = window.innerHeight - localAnchorElement.value.getBoundingClientRect().bottom;
+    const hasEnoughSpaceBelow =
+      spaceBelow > localTargetElement.value.getBoundingClientRect().height;
+    const hasEnoughSpaceAbove =
+      spaceAbove > localTargetElement.value.getBoundingClientRect().height;
+
+    if (localPreferredPosition.value.y === Position.Bottom) {
+      preferredOpenDirectionY.value =
+        hasEnoughSpaceBelow || spaceBelow > spaceAbove ? Position.Bottom : Position.Top;
+    }
+
+    if (localPreferredPosition.value.y === Position.Top) {
+      preferredOpenDirectionY.value =
+        hasEnoughSpaceAbove || spaceAbove > spaceBelow ? Position.Top : Position.Bottom;
+    }
+  }
+
+  function adjustPositionX(): void {
+    if (isSSR || !localAnchorElement.value || !localTargetElement.value) return;
+
+    const spaceRight = localAnchorElement.value.getBoundingClientRect().right;
+    const spaceLeft = window.innerWidth - localAnchorElement.value.getBoundingClientRect().left;
+    const hasEnoughSpaceLeft = spaceLeft > localTargetElement.value.getBoundingClientRect().width;
+    const hasEnoughSpaceRight = spaceRight > localTargetElement.value.getBoundingClientRect().width;
+
+    if (localPreferredPosition.value.x === Position.Right) {
+      preferredOpenDirectionX.value =
+        hasEnoughSpaceRight || spaceRight > spaceLeft ? Position.Right : Position.Left;
+    }
+
+    if (localPreferredPosition.value.x === Position.Left) {
+      preferredOpenDirectionX.value =
+        hasEnoughSpaceLeft || spaceLeft > spaceRight ? Position.Left : Position.Right;
+    }
+  }
+
+  return { isTop, isRight, isBottom, isLeft, adjustPositionY, adjustPositionX };
+}

package/composablesTs/useBreakpoint.d.ts

@@ -0,0 +1,7 @@
+export default function useBreakpoint(): {
+    isLaptopBreakpoint: import("vue").ComputedRef<boolean>;
+    isTabletBreakpoint: import("vue").ComputedRef<boolean>;
+    isMobileBreakpoint: import("vue").ComputedRef<boolean>;
+    isPortableBreakpoint: import("vue").ComputedRef<boolean>;
+    elementSize: import("vue").ComputedRef<string>;
+};

package/composablesTs/useBreakpoint.ts

@@ -0,0 +1,106 @@
+import { onMounted, ref, watch, computed, onBeforeUnmount } from "vue";
+import { isSSR } from "../utils/utilHelper.js";
+
+import type { Ref } from "vue";
+
+const BREAKPOINT_NAME = {
+  xs: "xs",
+  sm: "sm",
+  md: "md",
+  lg: "lg",
+  xl: "xl",
+  "2xl": "2xl",
+};
+
+const BREAKPOINT = {
+  xs: 0,
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536,
+};
+
+const mobileDevices = ["xs", "sm"];
+const portableDevices = ["xs", "sm", "md"];
+
+export default function useBreakpoint() {
+  let timeout: number;
+
+  const windowWidth: Ref<number | undefined> = ref(undefined);
+  const currentBreakpoint = ref(BREAKPOINT_NAME.xs);
+
+  const isMobileBreakpoint = computed(() => {
+    return mobileDevices.includes(currentBreakpoint.value);
+  });
+
+  const isTabletBreakpoint = computed(() => {
+    return mobileDevices.includes(currentBreakpoint.value);
+  });
+
+  const isLaptopBreakpoint = computed(() => {
+    return currentBreakpoint.value === BREAKPOINT_NAME.lg;
+  });
+
+  const isPortableBreakpoint = computed(() => {
+    return portableDevices.includes(currentBreakpoint.value);
+  });
+
+  const elementSize = computed(() => {
+    return isMobileBreakpoint.value ? BREAKPOINT_NAME.md : BREAKPOINT_NAME.lg;
+  });
+
+  onMounted(() => {
+    if (isSSR) return;
+
+    windowWidth.value = window.innerWidth;
+
+    window.addEventListener("resize", resizeListener, { passive: true });
+  });
+
+  onBeforeUnmount(() => {
+    if (isSSR) return;
+
+    window.removeEventListener("resize", resizeListener);
+  });
+
+  watch(windowWidth, setBreakpoint, { immediate: true });
+
+  function resizeListener() {
+    if (isSSR) return;
+
+    if (timeout) {
+      window.cancelAnimationFrame(timeout);
+    }
+
+    timeout = window.requestAnimationFrame(() => {
+      windowWidth.value = window.innerWidth;
+    });
+  }
+
+  function setBreakpoint(newWindowWidth: number | undefined) {
+    if (newWindowWidth === undefined) return;
+
+    currentBreakpoint.value = "xs";
+
+    if (newWindowWidth >= BREAKPOINT.sm && newWindowWidth < BREAKPOINT.md) {
+      currentBreakpoint.value = "sm";
+    } else if (newWindowWidth >= BREAKPOINT.md && newWindowWidth < BREAKPOINT.lg) {
+      currentBreakpoint.value = "md";
+    } else if (newWindowWidth >= BREAKPOINT.lg && newWindowWidth < BREAKPOINT.xl) {
+      currentBreakpoint.value = "lg";
+    } else if (newWindowWidth >= BREAKPOINT.xl && newWindowWidth < BREAKPOINT["2xl"]) {
+      currentBreakpoint.value = "xl";
+    } else if (newWindowWidth >= BREAKPOINT["2xl"]) {
+      currentBreakpoint.value = "2xl";
+    }
+  }
+
+  return {
+    isLaptopBreakpoint,
+    isTabletBreakpoint,
+    isMobileBreakpoint,
+    isPortableBreakpoint,
+    elementSize,
+  };
+}

package/composablesTs/useLocale.d.ts

@@ -0,0 +1,3 @@
+export declare const LocaleSymbol: unique symbol;
+export declare function createLocale(options: any): any;
+export declare function useLocale(): {};

package/composablesTs/useLocale.ts

@@ -0,0 +1,25 @@
+import { inject } from "vue";
+import createVuelessAdapter from "../adatper.locale/vueless.js";
+
+export const LocaleSymbol = Symbol.for("vueless:locale");
+
+function isLocaleInstance(obj): boolean {
+  return obj.name !== null;
+}
+
+export function createLocale(options) {
+  const i18n =
+    options?.adapter && isLocaleInstance(options?.adapter)
+      ? options?.adapter
+      : createVuelessAdapter(options);
+
+  return { ...i18n };
+}
+
+export function useLocale() {
+  const locale = inject(LocaleSymbol);
+
+  if (!locale) throw new Error("[vueless] Could not find injected locale instance");
+
+  return locale;
+}

package/composablesTs/useMutationObserver.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from "vue";
+export declare function useMutationObserver(target: Ref<HTMLElement | null>, callBack: () => void, config?: {
+    childList: boolean;
+    attributes: boolean;
+    characterData: boolean;
+}): {
+    observer: MutationObserver;
+} | undefined;