vueless 0.0.2 → 0.0.4

package/service.date/index.js

@@ -1,222 +0,0 @@
-import I18nServiceDefault from "vueless/service.i18n";
-import { enGB, ru, uk } from "date-fns/locale";
-import {
-  addDays,
-  addMonths,
-  endOfDay,
-  endOfMonth,
-  endOfTomorrow,
-  format,
-  getUnixTime,
-  isToday,
-  isTomorrow,
-  isYesterday,
-  minutesToSeconds,
-  startOfDay,
-  subMonths,
-  startOfYear,
-  endOfYear,
-  startOfMonth,
-  subDays,
-  secondsToMilliseconds,
-  getDaysInMonth,
-} from "date-fns";
-import { zonedTimeToUtc } from "date-fns-tz";
-import { format as TimeagoFormat, register as TimeagoRegister } from "timeago.js";
-import { uk as locale_UA, ru as locale_RU } from "timeago.js/lib/lang";
-
-const { getActiveLanguage } = new I18nServiceDefault();
-
-export default class DateServiceDefault {
-  #languages = {
-    en: enGB,
-    ru: ru,
-    ua: uk,
-  };
-
-  #settings = {
-    yearFormat: "y",
-    monthFormat: "MMMM",
-    dayFormat: "EEEE",
-    dateNumberFormat: "dd",
-    hourFormat: "HH",
-    minuteFormat: "mm",
-    secondFormat: "ss",
-  };
-
-  TOMORROW_TIMESTAMP = getUnixTime(endOfTomorrow());
-
-  constructor(languages = null) {
-    this.#languages = languages || this.#languages;
-  }
-
-  getDifferenceBetweenTimeZone(date) {
-    const diffInMinutesFrom = Math.abs(startOfDay(Number(date?.from)).getTimezoneOffset());
-    const diffInMinutesTo = Math.abs(endOfDay(Number(date?.to)).getTimezoneOffset());
-
-    return {
-      from: minutesToSeconds(diffInMinutesFrom),
-      to: minutesToSeconds(diffInMinutesTo),
-    };
-  }
-
-  formatDate(date, settings) {
-    const mergedSettings = {
-      ...this.#settings,
-      ...settings,
-    };
-    const {
-      dayFormat,
-      monthFormat,
-      yearFormat,
-      dateNumberFormat,
-      hourFormat,
-      minuteFormat,
-      i18n,
-      withTime,
-    } = mergedSettings;
-    const locale = this.#languages[getActiveLanguage()];
-
-    const day = format(date, dayFormat, { locale });
-    const month = format(date, monthFormat, { locale }).split(".").join(""); //Removes dot from Ukr and Rus localization;
-    const year = format(date, yearFormat);
-    const dateNumber = format(date, dateNumberFormat);
-    const hours = format(date, hourFormat);
-    const minutes = format(date, minuteFormat);
-
-    let formattedDate = `${day}, ${dateNumber} ${month} ${year}`;
-
-    if (isYesterday(date)) {
-      formattedDate = `${i18n.yesterday}, ${dateNumber} ${month} ${year}`;
-    }
-
-    if (isToday(date)) {
-      formattedDate = `${i18n.today}, ${dateNumber} ${month} ${year}`;
-    }
-
-    if (isTomorrow(date)) {
-      formattedDate = `${i18n.tomorrow}, ${dateNumber} ${month} ${year}`;
-    }
-
-    if (withTime) {
-      formattedDate = `${formattedDate} – ${hours}:${minutes}`;
-    }
-
-    return formattedDate;
-  }
-
-  dateConverter(timestamp, type = "date") {
-    const locale = this.#languages[getActiveLanguage()];
-    const date = new Date(timestamp * 1000);
-    let options = "";
-
-    if (type.includes("date")) {
-      options = "dd.MM.yyyy";
-    }
-
-    if (type.includes("time")) {
-      options = "HH:mm:ss";
-    }
-
-    if (type.includes("datetime")) {
-      options = "HH:mm dd.MM.yyyy";
-    }
-
-    if (type.includes("dateWithFullMonth")) {
-      options = "dd MMMM yyyy";
-    }
-
-    if (type.includes("dateWithFullMonthAndTime")) {
-      options = "dd MMMM yyyy HH:mm";
-    }
-
-    return format(date, options, { locale });
-  }
-
-  thirtyDaysAgo() {
-    const date = new Date();
-    const thirtyDaysAgo = subDays(date, getDaysInMonth(date));
-    const diffInSeconds = this.getDifferenceBetweenTimeZone({ from: startOfDay(thirtyDaysAgo) });
-
-    return getUnixTime(startOfDay(thirtyDaysAgo)) + diffInSeconds.from;
-  }
-
-  nextTwoWeek() {
-    const date = new Date();
-    const nextTwoWeek = addDays(date, 14);
-    const diffInSeconds = this.getDifferenceBetweenTimeZone({ to: nextTwoWeek });
-
-    return getUnixTime(endOfDay(nextTwoWeek)) + diffInSeconds.to;
-  }
-
-  sixMonthsAgo() {
-    const currentDate = new Date();
-    const startOfFiveMonthsAgoInSeconds = getUnixTime(startOfMonth(subMonths(currentDate, 5)));
-    const endOfCurrentMonthInSeconds = getUnixTime(endOfMonth(currentDate));
-    const diffInSeconds = this.getDifferenceBetweenTimeZone({
-      from: startOfMonth(subMonths(currentDate, 5)),
-      to: endOfMonth(currentDate),
-    });
-
-    return {
-      from: startOfFiveMonthsAgoInSeconds + diffInSeconds.from,
-      to: endOfCurrentMonthInSeconds + diffInSeconds.to,
-    };
-  }
-
-  currentMonth() {
-    const currentDate = new Date();
-    const startOfMonthInSeconds = getUnixTime(startOfMonth(currentDate));
-    const endOfMonthInSeconds = getUnixTime(endOfMonth(currentDate));
-    const diffInSeconds = this.getDifferenceBetweenTimeZone({
-      from: startOfMonth(currentDate),
-      to: endOfMonth(currentDate),
-    });
-
-    return {
-      from: startOfMonthInSeconds + diffInSeconds.from,
-      to: endOfMonthInSeconds + diffInSeconds.to,
-    };
-  }
-
-  currentYear() {
-    const currentDate = new Date();
-    const startOfYearInSeconds = getUnixTime(startOfYear(currentDate));
-    const endOfYearInSeconds = getUnixTime(endOfYear(currentDate));
-    const diffInSeconds = this.getDifferenceBetweenTimeZone({
-      from: startOfYear(currentDate),
-      to: endOfYear(currentDate),
-    });
-
-    return {
-      from: startOfYearInSeconds + diffInSeconds.from,
-      to: endOfYearInSeconds + diffInSeconds.to,
-    };
-  }
-
-  nextMonth() {
-    const nextMonth = addMonths(new Date(), 1);
-
-    const firstDayOfMonth = getUnixTime(startOfMonth(nextMonth));
-    const lastDayOfMonth = getUnixTime(endOfMonth(nextMonth));
-
-    return { firstDayOfMonth, lastDayOfMonth };
-  }
-
-  startOfSelectedDay(timestamp) {
-    const localTimeZone = "Etc/GMT";
-
-    const localStartOfDay = zonedTimeToUtc(startOfDay(timestamp), localTimeZone);
-
-    return getUnixTime(localStartOfDay);
-  }
-
-  getTimeAgo(date) {
-    TimeagoRegister("ua", locale_UA);
-    TimeagoRegister("ru", locale_RU);
-
-    const activeLanguage = getActiveLanguage();
-
-    return TimeagoFormat(secondsToMilliseconds(date), activeLanguage);
-  }
-}

package/service.i18n/index.js

@@ -1,145 +0,0 @@
-import { getCurrentInstance } from "vue";
-import { createI18n, useI18n } from "vue-i18n";
-import merge from "lodash.merge";
-import { fallbackLocale } from "vueless/service.ui";
-
-export default class I18nServiceDefault {
-  static FALLBACK_LOCALE = "en";
-  static LOCALE_KEY = "language";
-
-  #globalMessages = {};
-  #moduleMessages = {};
-
-  constructor() {
-    this._fallbackLocale = fallbackLocale || I18nServiceDefault.FALLBACK_LOCALE;
-
-    this.createI18nInstance();
-  }
-
-  createI18nInstance() {
-    this.i18nInstance = createI18n({
-      legacy: false,
-      messages: {},
-      locale: this.getActiveLanguage(),
-      fallbackLocale: this._fallbackLocale,
-      missing: this.missing,
-      warnHtmlMessage: false, // TODO: Think how to manage this later
-      pluralRules: {
-        ru: this.pluralizationRules,
-        ua: this.pluralizationRules,
-      },
-    });
-  }
-
-  async init() {
-    // Auto import global translations.
-    const global = import.meta.glob("@/i18n/**/*.yaml");
-
-    for (const path in global) {
-      const locales = await global[path]();
-      const lang = path.split(".").shift().split("/").pop();
-
-      this.#globalMessages[lang] = locales.default;
-    }
-
-    // Auto import translations from the modules.
-    const modules = import.meta.glob("@/modules/**/*.yaml");
-
-    for (const path in modules) {
-      const locales = await modules[path]();
-      const lang = path.split(".").shift().split("/").pop();
-      const module = path.split("modules").pop().split("/").at(1);
-
-      this.#moduleMessages[lang] = {
-        ...this.#moduleMessages[lang],
-        [module]: locales.default,
-      };
-    }
-
-    this.setMessages();
-  }
-
-  setMessages(module) {
-    const lang = this.getActiveLanguage();
-
-    const messages = this.#moduleMessages[lang]
-      ? merge(this.#moduleMessages[lang][module], this.#globalMessages[lang])
-      : this.#globalMessages[lang];
-
-    this.i18nInstance.global.setLocaleMessage(lang, messages);
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  missing(locale, key) {
-    // Handle issues here by Honeybadger.io or similar error tracking app.
-  }
-
-  pluralizationRules(value, plurals) {
-    let pluralIndex = 0;
-
-    if (value) {
-      const remainder = value % 10;
-      const teen = value > 10 && value < 20;
-      const endsWithOne = remainder === 1;
-
-      if (plurals < 4) {
-        pluralIndex = !teen && endsWithOne ? 1 : 2;
-      } else {
-        pluralIndex = 3;
-        if (!teen && endsWithOne) pluralIndex = 1;
-        if (!teen && remainder >= 2 && remainder <= 4) pluralIndex = 2;
-      }
-    }
-
-    return pluralIndex;
-  }
-
-  /**
-   * Get translation from global or local scopes
-   * @param localPath {string}
-   * @param params {$ObjMap}
-   * @returns {string}
-   */
-  getTranslation(localPath, params = {}) {
-    const { t, tm } = useI18n({ useScope: "local" });
-    const { t: tGlobal, tm: tmGlobal, te: teGlobal } = useI18n({ useScope: "global" });
-
-    const componentName = getCurrentInstance().type.name;
-    const globalPath = `${componentName}.${localPath}`;
-
-    let translation;
-
-    if (!localPath || !componentName) {
-      translation = "";
-    } else if (params?.isNested) {
-      translation = teGlobal(globalPath) ? tmGlobal(globalPath) : tm(localPath);
-    } else {
-      translation = teGlobal(globalPath) ? tGlobal(globalPath) : t(localPath);
-    }
-
-    return translation;
-  }
-
-  /**
-   * Save the active language to the localStorage
-   * @param lang
-   */
-  setActiveLanguage = (lang) => {
-    const localeKey = I18nServiceDefault.LOCALE_KEY;
-
-    this.i18nInstance.global.locale.value = lang;
-    localStorage.setItem(localeKey, lang);
-
-    this.setMessages();
-  };
-
-  /**
-   * Get the current active language from localStorage or set default if non exist
-   * @returns {string | string}
-   */
-  getActiveLanguage = () => {
-    const localeKey = I18nServiceDefault.LOCALE_KEY;
-
-    return localStorage.getItem(localeKey) || this._fallbackLocale;
-  };
-}

package/service.idb-keyval/index.js

@@ -1,37 +0,0 @@
-import { get as idbGet, set as idbSet, clear as idbClear, createStore } from "idb-keyval";
-import DataServiceDefault from "vueless/service.data";
-
-const mainIDBStore = createStore("main", "store");
-const instanceIDBStore = createStore("instance", "store");
-
-const { getRawValue } = new DataServiceDefault();
-
-const idbMain = {
-  async get(key) {
-    return await idbGet(key, mainIDBStore);
-  },
-
-  async set(key, value) {
-    await idbSet(key, getRawValue(value), mainIDBStore);
-  },
-
-  async clear() {
-    await idbClear(mainIDBStore);
-  },
-};
-
-const idbInstance = {
-  async get(key) {
-    return await idbGet(key, instanceIDBStore);
-  },
-
-  async set(key, value) {
-    await idbSet(key, getRawValue(value), instanceIDBStore);
-  },
-
-  async clear() {
-    await idbClear(instanceIDBStore);
-  },
-};
-
-export { idbMain, idbInstance };

package/service.jwt/index.js

@@ -1,27 +0,0 @@
-export default class JwtServiceDefault {
-  #AUTH_TOKEN = "token";
-  #AUTH_TOKEN_EXPIRES = "token-expires";
-  #VERSION_HASH = "version-hash";
-
-  getAuthToken() {
-    return window.localStorage.getItem(this.#AUTH_TOKEN);
-  }
-
-  getAuthTokenExpiresTime() {
-    return window.localStorage.getItem(this.#AUTH_TOKEN_EXPIRES);
-  }
-
-  saveAuthToken(token, expires) {
-    window.localStorage.setItem(this.#AUTH_TOKEN, token);
-    window.localStorage.setItem(this.#AUTH_TOKEN_EXPIRES, expires);
-  }
-
-  destroyAuthToken() {
-    window.localStorage.removeItem(this.#AUTH_TOKEN);
-    window.localStorage.removeItem(this.#AUTH_TOKEN_EXPIRES);
-  }
-
-  getVersionHash() {
-    return window.localStorage.getItem(this.#VERSION_HASH);
-  }
-}

package/service.money/index.js

@@ -1,86 +0,0 @@
-export default class MoneyServiceDefault {
-  SYMBOL_MINUS = "–";
-  SYMBOL_PLUS = "+";
-  SINGLE_ZERO = "0";
-  DOUBLE_ZERO = "00";
-  DEBIT_OBLIGATION = "debit";
-  CREDIT_OBLIGATION = "credit";
-  ADD_SPACE_IN_CARD_REG_EX = /(.{4})/g;
-  ADD_SPACE_IN_DINNER_CLUB_CARD_REG_EX = /(.{4})(.{6})(.{4})/g;
-  ADD_SPACE_IN_AMERICAN_EXPRESS_CARD_REG_EX = /(.{4})(.{6})(.{5})/g;
-  ADD_SPACE_IN_IBAN_REG_EX = /(.{2})(.{2})(.{6})(.{5})(.*)/g;
-  ADD_SPACE_IN_MONEY_REG_EX = /(\d)(?=(\d{3})+(\D|$))/g;
-  AMERICAN_EXPRESS_CARD_LENGTH = 15;
-  DINER_CLUB_CARD_LENGTH = 14;
-
-  MONEY_SIGN_TYPE = {
-    default: "default",
-    positive: "positive",
-    negative: "negative",
-  };
-
-  MONEY_COLORS = {
-    negative: "red",
-    positive: "green",
-    zero: "gray",
-  };
-
-  separatedMoney = (money, decimalPlaces = 2, delimiter = ",") => {
-    const roundedMoney = money ? money.toFixed(decimalPlaces) : 0;
-
-    let [integer, penny] = String(roundedMoney).split(".");
-
-    integer = integer.replace(this.ADD_SPACE_IN_MONEY_REG_EX, "$1 ");
-
-    if (roundedMoney === 0) {
-      integer = this.SINGLE_ZERO;
-      penny = this.DOUBLE_ZERO;
-    }
-
-    return { integer, penny, delimiter };
-  };
-
-  formatCardNumber = (card) => {
-    if (
-      card.length !== this.AMERICAN_EXPRESS_CARD_LENGTH &&
-      card.length !== this.DINER_CLUB_CARD_LENGTH
-    ) {
-      return MoneyServiceDefault.#formatCommonCardNumber(card);
-    }
-
-    if (card.length === this.AMERICAN_EXPRESS_CARD_LENGTH) {
-      return MoneyServiceDefault.#formatAmericanExpressCardNumber(card);
-    }
-
-    if (card.length === this.DINER_CLUB_CARD_LENGTH) {
-      return MoneyServiceDefault.#formatDinerClubCardNumber(card);
-    }
-  };
-
-  formatIban = (iban) => {
-    return iban.replace(this.ADD_SPACE_IN_IBAN_REG_EX, "$1 $2 $3 $4 $5 ");
-  };
-
-  static #formatAmericanExpressCardNumber(card) {
-    return card.replace(this.ADD_SPACE_IN_AMERICAN_EXPRESS_CARD_REG_EX, "$1 $2 $3 ");
-  }
-
-  static #formatDinerClubCardNumber(card) {
-    return card.replace(this.ADD_SPACE_IN_DINNER_CLUB_CARD_REG_EX, "$1 $2 $3 ");
-  }
-
-  static #formatCommonCardNumber(card) {
-    return card.replace(this.ADD_SPACE_IN_CARD_REG_EX, "$1 ");
-  }
-}
-
-export const {
-  SYMBOL_MINUS,
-  SINGLE_ZERO,
-  SYMBOL_PLUS,
-  MONEY_COLORS,
-  DOUBLE_ZERO,
-  DEBIT_OBLIGATION,
-  CREDIT_OBLIGATION,
-  MONEY_SIGN_TYPE,
-} = new MoneyServiceDefault();

package/service.redirect/index.js

@@ -1,20 +0,0 @@
-import I18nServiceDefault from "vueless/service.i18n";
-
-export default class RedirectServiceDefault {
-  static currentLocale = new I18nServiceDefault().getActiveLanguage();
-
-  static getFallbackLocale(redirectLinks, fallBackLocale) {
-    const localeKeys = Object.keys(redirectLinks);
-
-    return localeKeys.includes(fallBackLocale) ? fallBackLocale : localeKeys.at(0);
-  }
-
-  static redirect(redirectLinks, fallBackLocale) {
-    let href =
-      redirectLinks[this.currentLocale] ||
-      redirectLinks[this.getFallbackLocale(redirectLinks, fallBackLocale)] ||
-      redirectLinks[I18nServiceDefault.FALLBACK_LOCALE];
-
-    if (href) window.location = href;
-  }
-}

package/service.storybook/index.js

@@ -1,118 +0,0 @@
-import { renderToStaticMarkup } from "react-dom/server";
-import { decode } from "html-entities";
-import prettier2 from "prettier2";
-import HTMLParser from "prettier2/parser-html";
-
-const getComponentData = (componentName) => {
-  return require("/web-types.json").default.contributions.html.tags.find(
-    (item) => item.name === componentName,
-  );
-};
-
-export const getSlotNames = (componentName) => {
-  return getComponentData(componentName)?.slots?.map((item) => item.name);
-};
-
-export const getArgTypes = (componentName) => {
-  const component = getComponentData(componentName);
-
-  if (!component) return;
-
-  const types = {};
-
-  getSlotNames(componentName)?.forEach((slotName) => {
-    types[slotName] = { control: "text" };
-  });
-
-  component.attributes?.forEach((attribute) => {
-    const options = attribute.value.type.replace(/['|]/g, "").split(/\s+/);
-
-    if (options.length > 1) {
-      types[attribute.name] = {
-        options,
-        control: "select",
-        table: {
-          defaultValue: { summary: attribute.default || "" },
-        },
-      };
-    }
-  });
-
-  if (import.meta.env.VITE_STORYBOOK_FULL) {
-    component.events?.forEach((event) => {
-      const eventName = "on" + event.name.charAt(0).toUpperCase() + event.name.slice(1);
-
-      types[eventName] = {
-        action: event.name,
-        table: { category: "Storybook Events" },
-      };
-    });
-  }
-
-  return types;
-};
-
-export const renderToHTML = (templateSource, { args, argTypes }) => {
-  const componentArgs = {};
-
-  for (const [key, val] of Object.entries(argTypes)) {
-    const value = args[key];
-
-    if (
-      typeof val !== "undefined" &&
-      val.table &&
-      val.table.category === "props" &&
-      value !== val.defaultValue
-    ) {
-      componentArgs[key] = val;
-    }
-  }
-
-  const slotTemplateCode =
-    // eslint-disable-next-line vue/max-len
-    '<template v-for="(slot, index) of slots" :key="index" v-slot:[slot]><template v-if="args[slot]">{{args[slot]}}</template></template>';
-  const templateWrapperRegEx = /<template>([\s\S]*)<\/template>/i;
-  const vBindRegEx = /v-bind="\{([\s\S]*?)}"/g;
-
-  const propsString = Object.keys(componentArgs)
-    .map((key) => " " + propToSource(kebabCase(key), args[key]))
-    .join("");
-
-  const source = templateSource
-    .replace(slotTemplateCode, "")
-    .replace(templateWrapperRegEx, "$1")
-    .replace(vBindRegEx, propsString);
-
-  const markup = renderToStaticMarkup(source);
-
-  return prettier2.format(decode(markup), {
-    parser: "html",
-    plugins: [HTMLParser],
-    htmlWhitespaceSensitivity: "ignore",
-    tabWidth: 2,
-  });
-
-  function propToSource(key, val) {
-    const type = typeof val;
-
-    switch (type) {
-      case "boolean":
-        return val ? key : "";
-      case "string":
-        return `${key}="${val}"`;
-      default:
-        return `:${key}="${val}"`;
-    }
-  }
-
-  function kebabCase(str) {
-    return str
-      .split("")
-      .map((letter, idx) => {
-        return letter.toUpperCase() === letter
-          ? `${idx !== 0 ? "-" : ""}${letter.toLowerCase()}`
-          : letter;
-      })
-      .join("");
-  }
-};