vueless 0.0.1

package/library.vue-tailwind-3/l10n/zh-tw.js

@@ -0,0 +1,41 @@
+const MandarinTraditional = {
+  weekdays: {
+    shorthand: ["週日", "週一", "週二", "週三", "週四", "週五", "週六"],
+    longhand: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
+  },
+  months: {
+    shorthand: [
+      "一月",
+      "二月",
+      "三月",
+      "四月",
+      "五月",
+      "六月",
+      "七月",
+      "八月",
+      "九月",
+      "十月",
+      "十一月",
+      "十二月",
+    ],
+    longhand: [
+      "一月",
+      "二月",
+      "三月",
+      "四月",
+      "五月",
+      "六月",
+      "七月",
+      "八月",
+      "九月",
+      "十月",
+      "十一月",
+      "十二月",
+    ],
+  },
+  rangeSeparator: " 至 ",
+  weekAbbreviation: "週",
+};
+
+export default MandarinTraditional;
+export { MandarinTraditional };

package/library.vue-tailwind-3/l10n/zh.js

@@ -0,0 +1,41 @@
+const Mandarin = {
+  weekdays: {
+    shorthand: ["周日", "周一", "周二", "周三", "周四", "周五", "周六"],
+    longhand: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
+  },
+  months: {
+    shorthand: [
+      "一月",
+      "二月",
+      "三月",
+      "四月",
+      "五月",
+      "六月",
+      "七月",
+      "八月",
+      "九月",
+      "十月",
+      "十一月",
+      "十二月",
+    ],
+    longhand: [
+      "一月",
+      "二月",
+      "三月",
+      "四月",
+      "五月",
+      "六月",
+      "七月",
+      "八月",
+      "九月",
+      "十月",
+      "十一月",
+      "十二月",
+    ],
+  },
+  rangeSeparator: " 至 ",
+  weekAbbreviation: "周",
+};
+
+export default Mandarin;
+export { Mandarin };

package/library.vue-tailwind-3/services/date.service.js

@@ -0,0 +1,294 @@
+import merge from "lodash.merge";
+import cloneDeep from "lodash.clonedeep";
+import { English } from "../l10n/default";
+import { tokenRegex, revFormat, formats } from "./formatting.service";
+
+export const formatDate = (dateObj, format, customLocale) => {
+  if (!dateObj) {
+    return "";
+  }
+
+  const locale = customLocale || English;
+
+  return format
+    .split("")
+    .map((char, i, arr) => {
+      if (formats[char] && arr[i - 1] !== "\\") {
+        return formats[char](dateObj, locale);
+      }
+
+      if (char !== "\\") {
+        return char;
+      }
+
+      return "";
+    })
+    .join("");
+};
+
+export const parseDate = (date, format = "Y-m-d H:i:S", timeless, customLocale) => {
+  if (date !== 0 && !date) {
+    return undefined;
+  }
+
+  const locale = customLocale || English;
+
+  const localeTokenRegex = { ...tokenRegex };
+
+  localeTokenRegex.K = `(${locale.amPM[0]}|${
+    locale.amPM[1]
+  }|${locale.amPM[0].toLowerCase()}|${locale.amPM[1].toLowerCase()})`;
+
+  let parsedDate;
+  const dateOrig = date;
+
+  if (date instanceof Date) {
+    parsedDate = new Date(date.getTime());
+  } else if (
+    typeof date !== "string" &&
+    date.toFixed !== undefined // timestamp
+  ) {
+    // create a copy
+    parsedDate = new Date(date);
+  } else if (typeof date === "string") {
+    const datestr = String(date).trim();
+
+    if (datestr === "today") {
+      parsedDate = new Date();
+      // eslint-disable-next-line no-param-reassign
+      timeless = true;
+    } else if (
+      /Z$/.test(datestr) ||
+      /GMT$/.test(datestr) // datestrings w/ timezone
+    ) {
+      parsedDate = new Date(date);
+    } else {
+      parsedDate = new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0);
+
+      let matched;
+      const ops = [];
+
+      for (let i = 0, matchIndex = 0, regexStr = ""; i < format.length; i += 1) {
+        const token2 = format[i];
+        const isBackSlash = token2 === "\\";
+        const escaped = format[i - 1] === "\\" || isBackSlash;
+
+        if (localeTokenRegex[token2] && !escaped) {
+          regexStr += localeTokenRegex[token2];
+          const match = new RegExp(regexStr).exec(date);
+
+          if (match) {
+            matched = true;
+            ops[token2 !== "Y" ? "push" : "unshift"]({
+              fn: revFormat[token2],
+              val: match[(matchIndex += 1)],
+            });
+          }
+        } else if (!isBackSlash) {
+          regexStr += "."; // don't really care
+        }
+
+        // eslint-disable-next-line no-loop-func
+        ops.forEach((op) => {
+          const { fn } = op;
+          const { val } = op;
+
+          parsedDate = fn(parsedDate, String(val), locale) || parsedDate;
+        });
+      }
+
+      parsedDate = matched ? parsedDate : undefined;
+    }
+  }
+
+  /* istanbul ignore next */
+  // eslint-disable-next-line no-restricted-globals
+  if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) {
+    throw new Error(`Invalid date provided: ${dateOrig}`);
+  }
+
+  if (timeless === true) {
+    parsedDate.setHours(0, 0, 0, 0);
+  }
+
+  return parsedDate;
+};
+
+/**
+ * Compute the difference in dates, measured in ms
+ */
+export function compareDates(date1, date2, timeless = true) {
+  if (timeless !== false) {
+    return (
+      new Date(date1.getTime()).setHours(0, 0, 0, 0) -
+      new Date(date2.getTime()).setHours(0, 0, 0, 0)
+    );
+  }
+
+  return date1.getTime() - date2.getTime();
+}
+
+export const extractLocaleFromProps = (localeName, locales, defaultLocale) => {
+  const availableLocales = Object.keys(locales);
+  const find = availableLocales.find((l) => l === localeName);
+  const locale = find && locales[find] ? locales[find] : defaultLocale;
+
+  return merge(cloneDeep(English), locale);
+};
+
+export const buildDateParser =
+  (locale, customDateParser) =>
+  (date, format = "Y-m-d H:i:S", timeless) => {
+    if (customDateParser) {
+      return customDateParser(date, format, timeless, locale);
+    }
+
+    return parseDate(date, format, timeless, locale);
+  };
+
+export const buildDateFormatter =
+  (locale, customDateFormatter) =>
+  (date, format = "Y-m-d H:i:S") => {
+    if (customDateFormatter) {
+      return customDateFormatter(date, format, locale);
+    }
+
+    return formatDate(date, format, locale);
+  };
+
+/**
+ * it two dates are in the same month
+ */
+export function isSameMonth(date1, date2) {
+  return (
+    !!date1 &&
+    !!date2 &&
+    date1.getFullYear() === date2.getFullYear() &&
+    date1.getMonth() === date2.getMonth()
+  );
+}
+
+/**
+ * it two dates are in the same day
+ */
+export function isSameDay(date1, date2) {
+  return isSameMonth(date1, date2) && date1?.getDate() === date2?.getDate();
+}
+
+export function dayIsPartOfTheConditions(day, condition, dateParser, dateFormat) {
+  if (!day) {
+    return false;
+  }
+
+  if (typeof condition === "function") {
+    return condition(day);
+  }
+
+  if (typeof condition === "string" || condition instanceof String) {
+    const disabledDate = dateParser(condition, dateFormat);
+
+    return isSameDay(disabledDate, day);
+  }
+
+  if (condition instanceof Date) {
+    return isSameDay(condition, day);
+  }
+
+  if (Array.isArray(condition)) {
+    return condition.some((c) => dayIsPartOfTheConditions(day, c, dateParser, dateFormat));
+  }
+
+  return false;
+}
+
+export function dateIsOutOfRange(date, min, max, dateParser = null, dateFormat = null) {
+  let minDate;
+
+  if (typeof min === "string" || min instanceof String) {
+    if (!dateParser) {
+      throw new Error("strings needs a date parser");
+    }
+
+    if (!dateFormat) {
+      throw new Error("strings needs a date format");
+    }
+
+    minDate = dateParser(min, dateFormat);
+  } else {
+    minDate = min;
+  }
+
+  let maxDate;
+
+  if (typeof max === "string" || max instanceof String) {
+    if (!dateParser) {
+      throw new Error("strings needs a date parser");
+    }
+
+    if (!dateFormat) {
+      throw new Error("strings needs a date format");
+    }
+
+    maxDate = dateParser(max, dateFormat);
+  } else {
+    maxDate = max;
+  }
+
+  const time = date.getTime();
+
+  if (minDate && maxDate) {
+    return time < minDate.getTime() || time > maxDate.getTime();
+  }
+
+  if (minDate) {
+    return time < minDate.getTime();
+  }
+
+  if (maxDate) {
+    return time > maxDate.getTime();
+  }
+
+  return false;
+}
+
+export function addDays(date, amount = 1) {
+  const result = new Date(date);
+
+  result.setDate(result.getDate() + amount);
+
+  return result;
+}
+
+export function addMonths(date, amount = 1) {
+  let newDate = new Date(date.valueOf());
+
+  newDate.setMonth(date.getMonth() + amount);
+
+  // Means the current day has less days so the extra month is
+  // in the following month
+  if (newDate.getDate() !== date.getDate()) {
+    // Assign the last day of previous month
+    newDate = new Date(newDate.getFullYear(), newDate.getMonth(), 0);
+  }
+
+  return newDate;
+}
+
+export function addYears(date, amount = 1) {
+  let newDate = new Date(date.valueOf());
+
+  newDate.setFullYear(date.getFullYear() + amount);
+
+  // Means the current day has less days so the extra month is
+  // in the following month
+  if (newDate.getDate() !== date.getDate()) {
+    // Assign the last day of previous month
+    newDate = new Date(newDate.getFullYear(), newDate.getMonth(), 0);
+  }
+
+  return newDate;
+}
+
+export function lastDayOfMonth(date) {
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+}

package/library.vue-tailwind-3/services/formatting.service.js

@@ -0,0 +1,205 @@
+const pad = (number, length = 2) => `000${number}`.slice(length * -1);
+const int = (bool) => (bool === true ? 1 : 0);
+
+const doNothing = () => undefined;
+
+export const monthToStr = (monthNumber, shorthand, locale) =>
+  locale.months[shorthand ? "shorthand" : "longhand"][monthNumber];
+
+export const revFormat = {
+  D: doNothing,
+  F(dateObj, monthName, locale) {
+    dateObj.setMonth(locale.months.longhand.indexOf(monthName));
+  },
+  G: (dateObj, hour) => {
+    dateObj.setHours(parseFloat(hour));
+  },
+  H: (dateObj, hour) => {
+    dateObj.setHours(parseFloat(hour));
+  },
+  J: (dateObj, day) => {
+    dateObj.setDate(parseFloat(day));
+  },
+  K: (dateObj, amPM, locale) => {
+    dateObj.setHours(
+      (dateObj.getHours() % 12) + 12 * int(new RegExp(locale.amPM[1], "i").test(amPM)),
+    );
+  },
+  M(dateObj, shortMonth, locale) {
+    dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth));
+  },
+  S: (dateObj, seconds) => {
+    dateObj.setSeconds(parseFloat(seconds));
+  },
+  U: (_, unixSeconds) => new Date(parseFloat(unixSeconds) * 1000),
+
+  W(dateObj, weekNum, locale) {
+    const weekNumber = parseInt(weekNum, 10);
+    const date = new Date(dateObj.getFullYear(), 0, 2 + (weekNumber - 1) * 7, 0, 0, 0, 0);
+
+    date.setDate(date.getDate() - date.getDay() + locale.firstDayOfWeek);
+
+    return date;
+  },
+  Y: (dateObj, year) => {
+    dateObj.setFullYear(parseFloat(year));
+  },
+  Z: (_, ISODate) => new Date(ISODate),
+
+  d: (dateObj, day) => {
+    dateObj.setDate(parseFloat(day));
+  },
+  h: (dateObj, hour) => {
+    dateObj.setHours(parseFloat(hour));
+  },
+  i: (dateObj, minutes) => {
+    dateObj.setMinutes(parseFloat(minutes));
+  },
+  j: (dateObj, day) => {
+    dateObj.setDate(parseFloat(day));
+  },
+  l: doNothing,
+  m: (dateObj, month) => {
+    dateObj.setMonth(parseFloat(month) - 1);
+  },
+  n: (dateObj, month) => {
+    dateObj.setMonth(parseFloat(month) - 1);
+  },
+  s: (dateObj, seconds) => {
+    dateObj.setSeconds(parseFloat(seconds));
+  },
+  u: (_, unixMillSeconds) => new Date(parseFloat(unixMillSeconds)),
+  w: doNothing,
+  y: (dateObj, year) => {
+    dateObj.setFullYear(2000 + parseFloat(year));
+  },
+};
+
+export const tokenRegex = {
+  D: "(\\w+)",
+  F: "(\\w+)",
+  G: "(\\d\\d|\\d)",
+  H: "(\\d\\d|\\d)",
+  J: "(\\d\\d|\\d)\\w+",
+  K: "", // locale-dependent, setup on runtime
+  M: "(\\w+)",
+  S: "(\\d\\d|\\d)",
+  U: "(.+)",
+  W: "(\\d\\d|\\d)",
+  Y: "(\\d{4})",
+  Z: "(.+)",
+  d: "(\\d\\d|\\d)",
+  h: "(\\d\\d|\\d)",
+  i: "(\\d\\d|\\d)",
+  j: "(\\d\\d|\\d)",
+  l: "(\\w+)",
+  m: "(\\d\\d|\\d)",
+  n: "(\\d\\d|\\d)",
+  s: "(\\d\\d|\\d)",
+  u: "(.+)",
+  w: "(\\d\\d|\\d)",
+  y: "(\\d{2})",
+};
+
+export const formats = {
+  // get the date in UTC
+  Z: (date) => date.toISOString(),
+
+  // weekday name, short, e.g. Thu
+  D(date, locale) {
+    return locale.weekdays.shorthand[formats.w(date, locale)];
+  },
+
+  // full month name e.g. January
+  F(date, locale) {
+    return monthToStr(formats.n(date, locale) - 1, false, locale);
+  },
+
+  // padded hour 1-12
+  G(date, locale) {
+    return pad(formats.h(date, locale));
+  },
+
+  // hours with leading zero e.g. 03
+  H: (date) => pad(date.getHours()),
+
+  // day (1-30) with ordinal suffix e.g. 1st, 2nd
+  J(date, locale) {
+    return locale.ordinal !== undefined
+      ? date.getDate() + locale.ordinal(date.getDate())
+      : undefined;
+  },
+
+  // AM/PM
+  K: (date, locale) => locale.amPM[int(date.getHours() > 11)],
+
+  // shorthand month e.g. Jan, Sep, Oct, etc
+  M(date, locale) {
+    return monthToStr(date.getMonth(), true, locale);
+  },
+
+  // seconds 00-59
+  S: (date) => pad(date.getSeconds()),
+
+  // unix timestamp
+  U: (date) => date.getTime() / 1000,
+
+  W(givenDate) {
+    // return options.getWeek(date);
+    const date = new Date(givenDate.getTime());
+
+    date.setHours(0, 0, 0, 0);
+
+    // Thursday in current week decides the year.
+    date.setDate(date.getDate() + 3 - ((date.getDay() + 6) % 7));
+
+    // January 4 is always in week 1.
+    const week1 = new Date(date.getFullYear(), 0, 4);
+
+    // Adjust to Thursday in week 1 and count number of weeks from date to week1.
+    return (
+      1 +
+      Math.round(
+        ((date.getTime() - week1.getTime()) / 86400000 - 3 + ((week1.getDay() + 6) % 7)) / 7,
+      )
+    );
+  },
+
+  // full year e.g. 2016, padded (0001-9999)
+  Y: (date) => pad(date.getFullYear(), 4),
+
+  // day in month, padded (01-30)
+  d: (date) => pad(date.getDate()),
+
+  // hour from 1-12 (am/pm)
+  h: (date) => (date.getHours() % 12 ? date.getHours() % 12 : 12),
+
+  // minutes, padded with leading zero e.g. 09
+  i: (date) => pad(date.getMinutes()),
+
+  // day in month (1-30)
+  j: (date) => date.getDate(),
+
+  // weekday name, full, e.g. Thursday
+  l(date, locale) {
+    return locale.weekdays.longhand[date.getDay()];
+  },
+
+  // padded month number (01-12)
+  m: (date) => pad(date.getMonth() + 1),
+
+  // the month number (1-12)
+  n: (date) => date.getMonth() + 1,
+
+  // seconds 0-59
+  s: (date) => date.getSeconds(),
+
+  // Unix Milliseconds
+  u: (date) => date.getTime(),
+
+  // number of the day of the week
+  w: (date) => date.getDay(),
+
+  // last two digits of year e.g. 16 for 2016
+  y: (date) => String(date.getFullYear()).substring(2),
+};

package/library.vue-tailwind-3/services/vueTailwind.service.js

@@ -0,0 +1,41 @@
+class VueTailwindService {
+  awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+
+  isNumeric(char) {
+    return /^\d+$/.test(String(char));
+  }
+}
+
+export default new VueTailwindService();