mhz-helpers 1.3.26 → 1.4.0

package/dist/composables/useAuth.d.ts

@@ -0,0 +1,14 @@
+import * as vue from "vue";
+
+//#region src/composables/useAuth.d.ts
+declare const isAuth: Readonly<vue.Ref<boolean, boolean>>;
+declare function setAuth(auth: boolean): void;
+declare function logout(url: string, deleteAuthHeader: () => void, tokenName: string): void;
+declare function getCookieToken(tokenName: string): string | undefined;
+declare function setCookieToken(token: string, tokenName: string): void;
+declare function deleteCookieToken(tokenName: string): void;
+declare function useAuth(): {
+  auth: (token: string, setAuthHeader: (token: string) => void, tokenName: string) => void;
+};
+//#endregion
+export { deleteCookieToken, getCookieToken, isAuth, logout, setAuth, setCookieToken, useAuth };

package/dist/composables/useAuth.js

@@ -0,0 +1,36 @@
+import { getOneYearFromNow } from "../helpers/date.js";
+import { readonly, shallowRef } from "vue";
+
+//#region src/composables/useAuth.ts
+const isAuthLocal = shallowRef(false);
+const isAuth = readonly(isAuthLocal);
+function setAuth(auth) {
+	isAuthLocal.value = auth;
+}
+function logout(url, deleteAuthHeader, tokenName) {
+	deleteCookieToken(tokenName);
+	deleteAuthHeader();
+	globalThis.location.href = url;
+}
+function getCookieToken(tokenName) {
+	if (!document.cookie) return;
+	const { [tokenName]: token } = Object.fromEntries(document.cookie.split("; ").map((v) => v.split("=")));
+	return token;
+}
+function setCookieToken(token, tokenName) {
+	document.cookie = `${tokenName}=${token};Secure;SameSite=strict;expires=${getOneYearFromNow()}`;
+}
+function deleteCookieToken(tokenName) {
+	document.cookie = `${tokenName}=;expires=${(/* @__PURE__ */ new Date(0)).toUTCString()}`;
+}
+function useAuth() {
+	function auth(token, setAuthHeader, tokenName) {
+		setCookieToken(token, tokenName);
+		setAuthHeader(token);
+		setAuth(true);
+	}
+	return { auth };
+}
+
+//#endregion
+export { deleteCookieToken, getCookieToken, isAuth, logout, setAuth, setCookieToken, useAuth };

package/dist/composables/useCalendar.d.ts

@@ -0,0 +1,15 @@
+import * as vue from "vue";
+
+//#region src/composables/useCalendar.d.ts
+interface ICalendarDates {
+  dateFrom: Date;
+  dateTo: Date;
+}
+declare function useCalendar(): {
+  dateFrom: vue.ShallowRef<Date | undefined, Date | undefined>;
+  dateTo: vue.ShallowRef<Date | undefined, Date | undefined>;
+  isDatesReady: vue.ShallowRef<boolean, boolean>;
+  updateDates: (dates: ICalendarDates) => void;
+};
+//#endregion
+export { ICalendarDates, useCalendar };

package/dist/composables/useCalendar.js

@@ -0,0 +1,22 @@
+import { shallowRef } from "vue";
+
+//#region src/composables/useCalendar.ts
+function useCalendar() {
+	const dateFrom = shallowRef();
+	const dateTo = shallowRef();
+	const isDatesReady = shallowRef(false);
+	function updateDates(dates) {
+		dateFrom.value = dates.dateFrom;
+		dateTo.value = dates.dateTo;
+		isDatesReady.value = true;
+	}
+	return {
+		dateFrom,
+		dateTo,
+		isDatesReady,
+		updateDates
+	};
+}
+
+//#endregion
+export { useCalendar };

package/dist/composables/useDarkMode.d.ts

@@ -0,0 +1,9 @@
+import * as vue from "vue";
+
+//#region src/composables/useDarkMode.d.ts
+declare function useDarkMode(): {
+  isDarkMode: Readonly<vue.Ref<boolean, boolean>>;
+  toggleDarkMode: () => void;
+};
+//#endregion
+export { useDarkMode };

package/dist/composables/useDarkMode.js

@@ -0,0 +1,28 @@
+import { onBeforeMount, readonly, shallowRef } from "vue";
+
+//#region src/composables/useDarkMode.ts
+function useDarkMode() {
+	const isDarkModeState = shallowRef(false);
+	const isDarkMode = readonly(isDarkModeState);
+	onBeforeMount(() => {
+		const isLocalStorageValue = localStorage.getItem("dark");
+		if (isLocalStorageValue === null) localStorage.setItem("dark", "false");
+		else {
+			const isDarkModeEnabled = isLocalStorageValue === "true";
+			isDarkModeState.value = isDarkModeEnabled;
+			if (isDarkModeEnabled) document.body?.classList.add("dark");
+		}
+	});
+	function toggleDarkMode() {
+		isDarkModeState.value = !isDarkModeState.value;
+		document.body?.classList.toggle("dark", isDarkModeState.value);
+		localStorage.setItem("dark", String(isDarkModeState.value));
+	}
+	return {
+		isDarkMode,
+		toggleDarkMode
+	};
+}
+
+//#endregion
+export { useDarkMode };

package/dist/composables/useInfiniteScroll.d.ts

@@ -0,0 +1,12 @@
+import * as vue from "vue";
+import { Ref } from "vue";
+
+//#region src/composables/useInfiniteScroll.d.ts
+declare function useInfiniteScroll<T>(): {
+  page: vue.ShallowRef<number, number>;
+  allData: Ref<T[], T[]>;
+  addData: (data: T[]) => void;
+  handleScroll: (isLoading: boolean, pageToSet: number) => void;
+};
+//#endregion
+export { useInfiniteScroll };

package/dist/composables/useInfiniteScroll.js

@@ -0,0 +1,22 @@
+import { ref, shallowRef } from "vue";
+
+//#region src/composables/useInfiniteScroll.ts
+function useInfiniteScroll() {
+	const page = shallowRef(1);
+	const allData = ref([]);
+	function addData(data) {
+		allData.value = [...allData.value, ...data];
+	}
+	function handleScroll(isLoading, pageToSet) {
+		if (!isLoading) page.value = pageToSet > 0 ? pageToSet : 1;
+	}
+	return {
+		page,
+		allData,
+		addData,
+		handleScroll
+	};
+}
+
+//#endregion
+export { useInfiniteScroll };

package/dist/composables/usePage.d.ts

@@ -0,0 +1,35 @@
+import * as vue from "vue";
+import { Ref } from "vue";
+
+//#region src/composables/usePage.d.ts
+interface ISortOption {
+  value?: string;
+  isAsc: boolean;
+}
+interface IPageQuery {
+  page: number;
+  sort: ISortOption;
+  filter: object;
+}
+interface IPageParams {
+  page: number;
+}
+interface IPageSortParams extends IPageParams {
+  dir: string;
+  sort?: string;
+  initiator?: string;
+}
+declare function convertParams(params: Ref<IPageQuery | number>, initiator?: string): IPageSortParams | IPageParams;
+declare function usePage(filter?: object): {
+  query: Ref<IPageQuery, IPageQuery>;
+  resetQuery: (sortValue: string | ISortOption) => void;
+  setQueryPage: (pageToSet: number) => void;
+  setQueryFilter: (filterToSet?: object) => void;
+};
+declare function usePageNumber(): {
+  page: vue.ShallowRef<number, number>;
+  resetPage: () => void;
+  setPage: (pageToSet: number) => void;
+};
+//#endregion
+export { IPageParams, IPageQuery, IPageSortParams, ISortOption, convertParams, usePage, usePageNumber };

package/dist/composables/usePage.js

@@ -0,0 +1,96 @@
+import { ref, shallowRef, watch } from "vue";
+import { useRoute, useRouter } from "vue-router";
+
+//#region src/composables/usePage.ts
+function convertParams(params, initiator) {
+	if (typeof params.value === "number") return { page: params.value };
+	const { page, sort, filter } = params.value;
+	return {
+		page: page > 0 ? page : 1,
+		dir: sort.isAsc === false ? "desc" : "asc",
+		sort: sort.value,
+		initiator,
+		...filter
+	};
+}
+function usePage(filter) {
+	const router = useRouter();
+	const route = useRoute();
+	const query = ref({
+		page: route.query.page && Number(route.query.page > 0) ? Number(route.query.page) : 1,
+		sort: {
+			value: route.query.sort?.toString(),
+			isAsc: route.query.dir !== "desc"
+		},
+		filter: { ...filter }
+	});
+	function resetQuery(sortValue) {
+		query.value = typeof sortValue === "string" ? {
+			page: 1,
+			sort: {
+				value: sortValue,
+				isAsc: true
+			},
+			filter: {}
+		} : {
+			...query.value,
+			page: 1,
+			sort: sortValue
+		};
+	}
+	function setQueryPage(pageToSet) {
+		query.value.page = pageToSet > 0 ? pageToSet : 1;
+	}
+	function setQueryFilter(filterToSet) {
+		query.value = {
+			page: 1,
+			sort: query.value.sort,
+			filter: { ...filterToSet }
+		};
+	}
+	watch(() => [
+		query.value.page,
+		query.value.sort.value,
+		query.value.sort.isAsc
+	], () => {
+		router.push({
+			path: route.path,
+			query: {
+				page: query.value.page,
+				sort: query.value.sort.value,
+				dir: query.value.sort.isAsc ? "asc" : "desc"
+			}
+		});
+	});
+	return {
+		query,
+		resetQuery,
+		setQueryPage,
+		setQueryFilter
+	};
+}
+function usePageNumber() {
+	const router = useRouter();
+	const route = useRoute();
+	const page = shallowRef(Number(route.query.page || 1));
+	function resetPage() {
+		page.value = 1;
+	}
+	function setPage(pageToSet) {
+		page.value = pageToSet;
+	}
+	watch(() => page.value, () => {
+		router.push({
+			path: route.path,
+			query: { page: page.value }
+		});
+	});
+	return {
+		page,
+		resetPage,
+		setPage
+	};
+}
+
+//#endregion
+export { convertParams, usePage, usePageNumber };

package/dist/composables/usePageLock.d.ts

@@ -0,0 +1,4 @@
+//#region src/composables/usePageLock.d.ts
+declare function usePageLock(): void;
+//#endregion
+export { usePageLock };

package/dist/composables/usePageLock.js

@@ -0,0 +1,28 @@
+import { onBeforeUnmount, onMounted, ref } from "vue";
+
+//#region src/composables/usePageLock.ts
+function usePageLock() {
+	const pageLock = ref();
+	async function lockPage() {
+		pageLock.value = await navigator.wakeLock?.request();
+	}
+	function releasePage() {
+		pageLock.value?.release();
+		pageLock.value = void 0;
+	}
+	async function updatePageVisibility() {
+		if (document.visibilityState === "visible") await lockPage();
+		else releasePage();
+	}
+	onMounted(async () => {
+		await lockPage();
+		document.addEventListener("visibilitychange", updatePageVisibility);
+	});
+	onBeforeUnmount(() => {
+		releasePage();
+		document.removeEventListener("visibilitychange", updatePageVisibility);
+	});
+}
+
+//#endregion
+export { usePageLock };

package/dist/composables/usePagination.d.ts

@@ -0,0 +1,14 @@
+import * as vue from "vue";
+import { Ref } from "vue";
+
+//#region src/composables/usePagination.d.ts
+declare function usePagination<T>(dataRaw: Ref<{
+  data: T[];
+  total: number;
+} | undefined>): {
+  data: vue.ComputedRef<T[]>;
+  total: vue.ComputedRef<number>;
+  setPaginationPage: (pageToSet: number, page: number) => number;
+};
+//#endregion
+export { usePagination };

package/dist/composables/usePagination.js

@@ -0,0 +1,20 @@
+import { computed } from "vue";
+
+//#region src/composables/usePagination.ts
+function usePagination(dataRaw) {
+	const data = computed(() => dataRaw.value?.data || []);
+	const total = computed(() => dataRaw.value?.total || 0);
+	function setPaginationPage(pageToSet, page) {
+		if (!total.value) return page;
+		if (pageToSet < 1 || pageToSet > total.value) return page;
+		return pageToSet;
+	}
+	return {
+		data,
+		total,
+		setPaginationPage
+	};
+}
+
+//#endregion
+export { usePagination };

package/dist/composables/usePwa.d.ts

@@ -0,0 +1,13 @@
+import * as vue from "vue";
+
+//#region src/composables/usePwa.d.ts
+interface IPromptEvent extends Event {
+  prompt: () => Promise<void>;
+}
+declare function usePwa(): {
+  installPWA: () => Promise<void>;
+  isShowInstallPWA: vue.ShallowRef<boolean, boolean>;
+  isPWACanBeInstalled: vue.ShallowRef<boolean, boolean>;
+};
+//#endregion
+export { IPromptEvent, usePwa };

package/dist/composables/usePwa.js

@@ -0,0 +1,41 @@
+import { onBeforeUnmount, onMounted, ref, shallowRef } from "vue";
+
+//#region src/composables/usePwa.ts
+function usePwa() {
+	const isShowInstallPWA = shallowRef(false);
+	const isPWACanBeInstalled = shallowRef(false);
+	const installPWAPrompt = ref();
+	async function installPWA() {
+		if (installPWAPrompt.value) {
+			await installPWAPrompt.value.prompt();
+			setTimeout(() => {
+				isShowInstallPWA.value = false;
+				installPWAPrompt.value = void 0;
+			}, 100);
+		}
+	}
+	function isInstallPromptEvent(e) {
+		return !!e && "prompt" in e;
+	}
+	function installHandler(event) {
+		if (isInstallPromptEvent(event)) {
+			isPWACanBeInstalled.value = true;
+			isShowInstallPWA.value = true;
+			installPWAPrompt.value = event;
+		}
+	}
+	onMounted(() => {
+		globalThis.addEventListener("beforeinstallprompt", installHandler);
+	});
+	onBeforeUnmount(() => {
+		globalThis.removeEventListener("beforeinstallprompt", installHandler);
+	});
+	return {
+		installPWA,
+		isShowInstallPWA,
+		isPWACanBeInstalled
+	};
+}
+
+//#endregion
+export { usePwa };

package/dist/composables/useRouteId.d.ts

@@ -0,0 +1,8 @@
+import * as vue from "vue";
+
+//#region src/composables/useRouteId.d.ts
+declare function useRouteId(title: string, isQuery?: boolean): {
+  id: vue.ComputedRef<string>;
+};
+//#endregion
+export { useRouteId };

package/dist/composables/useRouteId.js

@@ -0,0 +1,13 @@
+import { computed } from "vue";
+import { useRoute } from "vue-router";
+
+//#region src/composables/useRouteId.ts
+function useRouteId(title, isQuery) {
+	const route = useRoute();
+	return { id: computed(() => {
+		return (isQuery ? route.query[title]?.toString() : route.params[title]?.toString()) || "";
+	}) };
+}
+
+//#endregion
+export { useRouteId };

package/dist/composables/useTimer.d.ts

@@ -0,0 +1,11 @@
+import * as vue from "vue";
+
+//#region src/composables/useTimer.d.ts
+declare function useTimer(): {
+  timer: vue.ComputedRef<string>;
+  duration: vue.ComputedRef<number>;
+  startTimer: () => void;
+  stopTimer: () => void;
+};
+//#endregion
+export { useTimer };

package/dist/composables/useTimer.js

@@ -0,0 +1,38 @@
+import { addZero } from "../helpers/date.js";
+import { computed, shallowRef } from "vue";
+
+//#region src/composables/useTimer.ts
+function useTimer() {
+	const secondsRaw = shallowRef(0);
+	const minutesRaw = shallowRef(0);
+	const timer = computed(() => `${addZero(minutesRaw.value)}:${addZero(secondsRaw.value)}`);
+	const duration = computed(() => minutesRaw.value * 60 + secondsRaw.value);
+	let interval = null;
+	function updateTime() {
+		secondsRaw.value++;
+		if (secondsRaw.value === 60) {
+			minutesRaw.value++;
+			secondsRaw.value = 0;
+		}
+	}
+	function startTimer() {
+		if (!interval) interval = setInterval(updateTime, 1e3);
+	}
+	function stopTimer() {
+		if (interval) {
+			clearInterval(interval);
+			interval = null;
+		}
+		secondsRaw.value = 0;
+		minutesRaw.value = 0;
+	}
+	return {
+		timer,
+		duration,
+		startTimer,
+		stopTimer
+	};
+}
+
+//#endregion
+export { useTimer };

package/dist/composables/useValidate.d.ts

@@ -0,0 +1,19 @@
+import { TLocale } from "../locales/types.js";
+import * as vue from "vue";
+import { Ref } from "vue";
+import * as async_validator0 from "async-validator";
+import { RuleItem } from "async-validator";
+
+//#region src/composables/useValidate.d.ts
+declare function useValidate<T>(formData: Ref<T>, rules: Partial<{ [fieldName in keyof T]: (RuleItem | ((locale: TLocale) => RuleItem))[] }>, locale?: TLocale): {
+  error: (field: string) => string | undefined;
+  errors: vue.ComputedRef<Record<string, async_validator0.ValidateError[]> | undefined>;
+  isValid: () => boolean;
+};
+declare function required(locale?: TLocale): RuleItem;
+declare function email(locale?: TLocale): RuleItem;
+declare function letters(locale?: TLocale): RuleItem;
+declare function min(value: number, locale?: TLocale): RuleItem;
+declare function max(value: number, locale?: TLocale): RuleItem;
+//#endregion
+export { email, letters, max, min, required, useValidate };

package/dist/composables/useValidate.js

@@ -0,0 +1,62 @@
+import { MESSAGES } from "../locales/index.js";
+import { computed, shallowRef } from "vue";
+import { useAsyncValidator } from "@vueuse/integrations/useAsyncValidator";
+
+//#region src/composables/useValidate.ts
+function useValidate(formData, rules, locale = "ru") {
+	const { errorFields, isFinished, pass } = useAsyncValidator(formData, computed(() => {
+		return Object.entries(rules).reduce((acc, [key, ruleArray]) => {
+			acc[key] = Array.isArray(ruleArray) ? ruleArray.map((rule) => typeof rule === "function" ? rule(locale) : rule) : [];
+			return acc;
+		}, {});
+	}), { validateOption: { suppressWarning: true } });
+	const tries = shallowRef(0);
+	function isValid() {
+		tries.value++;
+		return pass.value && isFinished.value;
+	}
+	const errors = computed(() => tries.value ? errorFields.value : void 0);
+	function error(field) {
+		return errors.value?.[field]?.[0]?.message;
+	}
+	return {
+		error,
+		errors,
+		isValid
+	};
+}
+function required(locale = "ru") {
+	return {
+		required: true,
+		whitespace: true,
+		message: MESSAGES[locale].fieldIsRequired
+	};
+}
+function email(locale = "ru") {
+	return {
+		type: "email",
+		message: MESSAGES[locale].enterCorrectEmail
+	};
+}
+function letters(locale = "ru") {
+	return {
+		validator: (_rule, value) => /^[a-zA-Zа-яА-ЯёЁ\s-]+$/.test(value) || value.length === 0,
+		type: "string",
+		message: MESSAGES[locale].onlyLetters
+	};
+}
+function min(value, locale = "ru") {
+	return {
+		min: value,
+		message: `${MESSAGES[locale].minSymbols}: ${value}`
+	};
+}
+function max(value, locale = "ru") {
+	return {
+		max: value,
+		message: `${MESSAGES[locale].maxSymbols}: ${value}`
+	};
+}
+
+//#endregion
+export { email, letters, max, min, required, useValidate };

package/dist/helpers/api.d.ts

@@ -0,0 +1,10 @@
+import * as axios$1 from "axios";
+
+//#region src/helpers/api.d.ts
+declare const api: axios$1.AxiosStatic;
+declare function setBaseURL(url: string): void;
+declare function setAuthHeader(token: string): void;
+declare function deleteAuthHeader(): void;
+declare function handleError(error: unknown): string;
+//#endregion
+export { api, deleteAuthHeader, handleError, setAuthHeader, setBaseURL };

package/dist/helpers/api.js

@@ -0,0 +1,19 @@
+import axios from "axios";
+
+//#region src/helpers/api.ts
+const api = axios;
+function setBaseURL(url) {
+	api.defaults.baseURL = url;
+}
+function setAuthHeader(token) {
+	api.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+}
+function deleteAuthHeader() {
+	api.defaults.headers.common["Authorization"] = void 0;
+}
+function handleError(error) {
+	return api.isAxiosError(error) ? error.response?.data.message : "Ошибка";
+}
+
+//#endregion
+export { api, deleteAuthHeader, handleError, setAuthHeader, setBaseURL };

package/dist/helpers/clone.d.ts

@@ -0,0 +1,4 @@
+//#region src/helpers/clone.d.ts
+declare function clone<T>(obj: T): T;
+//#endregion
+export { clone };

package/dist/helpers/clone.js

@@ -0,0 +1,44 @@
+import { toRaw } from "vue";
+
+//#region src/helpers/clone.ts
+function deepClone(obj) {
+	if (obj === null) return obj;
+	if (typeof obj !== "object") return obj;
+	if (obj instanceof Date) return new Date(obj);
+	if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	if (obj instanceof Set) {
+		const clonedSet = /* @__PURE__ */ new Set();
+		obj.forEach((value) => {
+			clonedSet.add(deepClone(value));
+		});
+		return clonedSet;
+	}
+	if (obj instanceof Map) {
+		const clonedMap = /* @__PURE__ */ new Map();
+		obj.forEach((value, key) => {
+			clonedMap.set(deepClone(key), deepClone(value));
+		});
+		return clonedMap;
+	}
+	if (typeof obj === "object") {
+		const cloned = {};
+		Object.getOwnPropertySymbols(obj).forEach((symbol) => {
+			if (Object.getOwnPropertyDescriptor(obj, symbol)?.enumerable) Object.defineProperty(cloned, symbol, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: deepClone(obj[symbol])
+			});
+		});
+		for (const key in obj) if (Object.hasOwn(obj, key)) cloned[key] = deepClone(obj[key]);
+		return cloned;
+	}
+	return obj;
+}
+function clone(obj) {
+	return deepClone(toRaw(obj));
+}
+
+//#endregion
+export { clone };