@winchsa/ui 0.1.33 → 0.1.34

package/dist/utils/i18n.d.ts

@@ -0,0 +1,8 @@
+export declare const i18n: () => import("vue-i18n").I18n<{
+    en: any;
+    ar: any;
+}, {}, {}, string, false>;
+export declare const createI18nInstance: (messages: object) => import("vue-i18n").I18n<{
+    en: any;
+    ar: any;
+}, {}, {}, string, false>;

package/dist/utils/i18n.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.i18n = exports.createI18nInstance = void 0;
+var _vueI18n = require("vue-i18n");
+var _en = _interopRequireDefault(require("../lang/en.json"));
+var _ar = _interopRequireDefault(require("../lang/ar.json"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const defaultMessages = {
+  en: _en.default,
+  ar: _ar.default
+};
+let _i18nInstance = (0, _vueI18n.createI18n)({
+  legacy: false,
+  locale: "ar",
+  fallbackLocale: "ar",
+  globalInjection: true,
+  messages: defaultMessages
+});
+const i18n = () => _i18nInstance;
+exports.i18n = i18n;
+const createI18nInstance = messages => {
+  const mergedMessages = (0, _utils.mergeDeep)(defaultMessages, messages);
+  _i18nInstance = (0, _vueI18n.createI18n)({
+    legacy: false,
+    locale: "ar",
+    fallbackLocale: "ar",
+    globalInjection: true,
+    messages: mergedMessages
+  });
+  return _i18nInstance;
+};
+exports.createI18nInstance = createI18nInstance;

package/dist/utils/i18n.mjs

@@ -0,0 +1,27 @@
+import { createI18n } from "vue-i18n";
+import en from "../lang/en.json";
+import ar from "../lang/ar.json";
+import { mergeDeep } from "./utils.mjs";
+const defaultMessages = {
+  en,
+  ar
+};
+let _i18nInstance = createI18n({
+  legacy: false,
+  locale: "ar",
+  fallbackLocale: "ar",
+  globalInjection: true,
+  messages: defaultMessages
+});
+export const i18n = () => _i18nInstance;
+export const createI18nInstance = (messages) => {
+  const mergedMessages = mergeDeep(defaultMessages, messages);
+  _i18nInstance = createI18n({
+    legacy: false,
+    locale: "ar",
+    fallbackLocale: "ar",
+    globalInjection: true,
+    messages: mergedMessages
+  });
+  return _i18nInstance;
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './apiUrl';
+export * from './client';
+export * from './files';
+export * from './formValidation';
+export * from './formatters';
+export * from './queryParams';
+export * from './ruleValidator';
+export * from './toaster';
+export * from './i18n';
+export * from './utils';

package/dist/utils/index.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _apiUrl = require("./apiUrl");
+Object.keys(_apiUrl).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _apiUrl[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _apiUrl[key];
+    }
+  });
+});
+var _client = require("./client");
+Object.keys(_client).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _client[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _client[key];
+    }
+  });
+});
+var _files = require("./files");
+Object.keys(_files).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _files[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _files[key];
+    }
+  });
+});
+var _formValidation = require("./formValidation");
+Object.keys(_formValidation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _formValidation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _formValidation[key];
+    }
+  });
+});
+var _formatters = require("./formatters");
+Object.keys(_formatters).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _formatters[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _formatters[key];
+    }
+  });
+});
+var _queryParams = require("./queryParams");
+Object.keys(_queryParams).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _queryParams[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _queryParams[key];
+    }
+  });
+});
+var _ruleValidator = require("./ruleValidator");
+Object.keys(_ruleValidator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ruleValidator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ruleValidator[key];
+    }
+  });
+});
+var _toaster = require("./toaster");
+Object.keys(_toaster).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toaster[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _toaster[key];
+    }
+  });
+});
+var _i18n = require("./i18n");
+Object.keys(_i18n).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _i18n[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _i18n[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});

package/dist/utils/index.mjs

@@ -0,0 +1,10 @@
+export * from "./apiUrl.mjs";
+export * from "./client.mjs";
+export * from "./files.mjs";
+export * from "./formValidation.mjs";
+export * from "./formatters.mjs";
+export * from "./queryParams.mjs";
+export * from "./ruleValidator.mjs";
+export * from "./toaster.mjs";
+export * from "./i18n.mjs";
+export * from "./utils.mjs";

package/dist/utils/queryParams.d.ts

@@ -0,0 +1,4 @@
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+import type { Params } from '../types';
+export declare const buildQueryString: (params: Params | undefined) => string;
+export declare const decodeRouteParams: (to?: RouteLocationNormalizedLoaded) => URLSearchParams;

package/dist/utils/queryParams.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeRouteParams = exports.buildQueryString = void 0;
+var _vueRouter = require("vue-router");
+const buildQueryString = params => {
+  const inputParams = params || {};
+  return Object.entries(inputParams).filter(([key, value]) => {
+    return key && value !== null && value !== void 0 && (Array.isArray(value) && value.length !== 0 || String(value).trim().length > 0);
+  }).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      return value.map((subValue, index) => subValue ? `${key}[${index}]=${subValue}` : null).join("&");
+    }
+    return `${key}=${value}`;
+  }).join("&");
+};
+exports.buildQueryString = buildQueryString;
+const decodeRouteParams = to => {
+  const route = to || (0, _vueRouter.useRoute)();
+  const path = decodeURIComponent(route.fullPath.replace(route.path, ""));
+  const params = new URLSearchParams(decodeURIComponent(path));
+  return params;
+};
+exports.decodeRouteParams = decodeRouteParams;

package/dist/utils/queryParams.mjs

@@ -0,0 +1,18 @@
+import { useRoute } from "vue-router";
+export const buildQueryString = (params) => {
+  const inputParams = params || {};
+  return Object.entries(inputParams).filter(([key, value]) => {
+    return key && value !== null && value !== void 0 && (Array.isArray(value) && value.length !== 0 || String(value).trim().length > 0);
+  }).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      return value.map((subValue, index) => subValue ? `${key}[${index}]=${subValue}` : null).join("&");
+    }
+    return `${key}=${value}`;
+  }).join("&");
+};
+export const decodeRouteParams = (to) => {
+  const route = to || useRoute();
+  const path = decodeURIComponent(route.fullPath.replace(route.path, ""));
+  const params = new URLSearchParams(decodeURIComponent(path));
+  return params;
+};

package/dist/utils/ruleValidator.d.ts

@@ -0,0 +1,41 @@
+import type { VForm } from 'vuetify/components/VForm';
+export declare const ruleValidator: () => {
+    fileValidator: (file: File | undefined, maxSizeInMB: number, types: string[]) => boolean | undefined;
+    requiredValidator: (value: unknown) => string | true;
+    requiredLocationValidator: (locations: Array<{
+        name?: string;
+        address?: string;
+        lat?: number | null;
+        lng?: number | null;
+    }> | {
+        name?: string;
+        address?: string;
+        lat?: number | null;
+        lng?: number | null;
+    }) => string | true;
+    emailValidator: (value: unknown) => string | true;
+    alphaValidator: (value: unknown) => string | true;
+    alphaDashValidator: (value: unknown) => string | true;
+    alphaWithNumberValidator: (value: unknown) => string | true;
+    betweenValidator: (value: unknown, min: number, max: number) => string | true;
+    integerValidator: (value: unknown) => string | true;
+    numberValidator: (value: unknown) => string | true;
+    confirmedValidator: (value: string, target: string) => string | true;
+    urlValidator: (value: unknown) => string | true;
+    lengthValidator: (value: unknown, length: number) => string | true;
+    ibanValidator: (value: unknown) => string | true;
+    dateValidator: (value: unknown) => string | true;
+    regexValidator: (value: string, regex: RegExp, message?: string) => string | true;
+    idNumberValidator: (value: string | number | null) => string | undefined;
+    requiredManualDateValidator: (value: {
+        year?: string;
+        month?: string;
+        day?: string;
+    }) => string | true;
+    requiredPlateValidator: (value: string[] | null | undefined) => string | true;
+};
+export declare const useFormValidation: () => {
+    validateAndScroll: (refVForm: VForm | undefined) => Promise<boolean>;
+    validationType: import("vue").Ref<"input" | "submit", "input" | "submit">;
+    scrollToError: () => Promise<void>;
+};

package/dist/utils/ruleValidator.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFormValidation = exports.ruleValidator = void 0;
+var _vue = require("vue");
+var _vueI18n = require("vue-i18n");
+var _toaster = require("./toaster");
+var _utils = require("./utils");
+const ruleValidator = () => {
+  const {
+    t
+  } = (0, _vueI18n.useI18n)();
+  const requiredValidator = value => {
+    if ((0, _utils.isNullOrUndefined)(value) || (0, _utils.isEmptyArray)(value) || value === false) {
+      return t("validation.required");
+    }
+    return !!String(value).trim().length || t("validation.required");
+  };
+  const requiredLocationValidator = locations => {
+    const locationArray = Array.isArray(locations) ? locations : [locations];
+    if (!locationArray || locationArray.length === 0) {
+      return t("validation.required");
+    }
+    for (const location of locationArray) {
+      if (!location || !location.address || !String(location.address).trim() || location.lat === null || typeof location.lat !== "number" || location.lng === null || typeof location.lng !== "number") {
+        return t("validation.required");
+      }
+    }
+    return true;
+  };
+  const ibanValidator = value => {
+    if ((0, _utils.isNullOrUndefined)(value) || (0, _utils.isEmptyArray)(value) || value === false || String(value).length !== 24) {
+      return t("validation.iban");
+    }
+    return !!String(value).trim().length || t("validation.iban");
+  };
+  const idNumberValidator = value => {
+    const str = value?.toString() || "";
+    const validStarts = ["1", "2", "3", "4"];
+    if (str.length !== 10 || !validStarts.includes(str[0])) {
+      return t("validation.invalid");
+    }
+  };
+  const requiredManualDateValidator = value => {
+    if ((0, _utils.isEmpty)(value?.day) || (0, _utils.isEmpty)(value?.month) || (0, _utils.isEmpty)(value?.year)) {
+      return t("validation.required");
+    }
+    return true;
+  };
+  const emailValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    const re = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
+    if (Array.isArray(value)) {
+      return value.every(val => re.test(String(val))) || t("validation.email");
+    }
+    return re.test(String(value)) || t("validation.email");
+  };
+  const confirmedValidator = (value, target) => value === target || t("validation.confirmed");
+  const betweenValidator = (value, min, max) => {
+    const valueAsNumber = Number(value);
+    return Number(min) <= valueAsNumber && Number(max) >= valueAsNumber || t("validation.between", {
+      min,
+      max
+    });
+  };
+  const integerValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    if (Array.isArray(value)) {
+      return value.every(val => /^-?[0-9]+$/.test(String(val))) || t("validation.integer");
+    }
+    return /^-?[0-9]+$/.test(String(value)) || t("validation.integer");
+  };
+  const numberValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    return /^\d+(\.\d+)?$/.test(String(value)) || t("validation.number");
+  };
+  const alphaValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    return /^[A-Za-z\u0600-\u06FF\s]*$/i.test(String(value)) || t("validation.alphabetic");
+  };
+  const alphaWithNumberValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    return /^[A-Za-z\u0600-\u06FF0-9\s]*$/.test(String(value)) || t("validation.alphabetic");
+  };
+  const urlValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    const re = /^(http[s]?:\/\/){0,1}(www\.){0,1}[a-zA-Z0-9.-]+\.[a-zA-Z]{2,5}[.]?/;
+    return re.test(String(value)) || t("validation.url");
+  };
+  const lengthValidator = (value, length) => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    return String(value).length === length || t("validation.length", {
+      length
+    });
+  };
+  const alphaDashValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    const valueAsString = String(value);
+    return /^[0-9A-Z_-]*$/i.test(valueAsString) || t("validation.alpha_dash");
+  };
+  const fileValidator = (file, maxSizeInMB, types) => {
+    if (!file) {
+      return false;
+    }
+    if (file.size > maxSizeInMB * 1024 * 1024) {
+      (0, _toaster.toaster)().error(t("validation.file_size_limit_exceeded", {
+        size: maxSizeInMB
+      }));
+      return;
+    }
+    if (!types.includes(file.type)) {
+      (0, _toaster.toaster)().error(t("validation.file_type_not_allowed", {
+        types: types.map(type => type.split("/")[1]).join(", ")
+      }));
+      return;
+    }
+    return true;
+  };
+  const requiredPlateValidator = value => {
+    if (!value || !value?.every(val => val !== "")) {
+      return t("validation.required");
+    }
+    return true;
+  };
+  const dateValidator = value => {
+    if ((0, _utils.isEmpty)(value)) {
+      return true;
+    }
+    const dateString = String(value);
+    const datePattern = /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/(\d{4})$/;
+    if (!datePattern.test(dateString)) {
+      return t("validation.date", {
+        format: "DD/MM/YYYY"
+      });
+    }
+    return true;
+  };
+  const regexValidator = (value, regex, message) => {
+    return regex.test(value) || message || t("validation.invalid");
+  };
+  return {
+    fileValidator,
+    requiredValidator,
+    requiredLocationValidator,
+    emailValidator,
+    alphaValidator,
+    alphaDashValidator,
+    alphaWithNumberValidator,
+    betweenValidator,
+    integerValidator,
+    numberValidator,
+    confirmedValidator,
+    urlValidator,
+    lengthValidator,
+    ibanValidator,
+    dateValidator,
+    regexValidator,
+    idNumberValidator,
+    requiredManualDateValidator,
+    requiredPlateValidator
+  };
+};
+exports.ruleValidator = ruleValidator;
+const useFormValidation = () => {
+  const validationType = (0, _vue.ref)("submit");
+  const validateAndScroll = async refVForm => {
+    const isValid = await refVForm?.validate();
+    await scrollToError();
+    if (isValid?.valid === false) {
+      await scrollToError();
+      validationType.value = "input";
+      return false;
+    }
+    return true;
+  };
+  const scrollToError = async () => {
+    validationType.value = "input";
+    await (0, _vue.nextTick)(() => {
+      const el = document.querySelector(".v-messages__message:first-of-type");
+      el?.scrollIntoView({
+        behavior: "smooth",
+        block: "center"
+      });
+    });
+  };
+  return {
+    validateAndScroll,
+    validationType,
+    scrollToError
+  };
+};
+exports.useFormValidation = useFormValidation;