v-calendar-3 1.0.0

package/src/utils/locale.ts

@@ -0,0 +1,275 @@
+import {
+  type PageConfig,
+  type CachedPage,
+  getPageKey,
+  getCachedPage,
+  getPage,
+} from './page';
+import {
+  type DateSource,
+  type DateOptions,
+  type DayOfWeek,
+  type MonthParts,
+  type MonthInYear,
+  type SimpleDateParts,
+  type TimeNames,
+  DatePatchKeys,
+  applyRulesForDateParts,
+  daysInWeek,
+  formatDate,
+  parseDate,
+  getDateParts,
+  getDateFromParts,
+  getDayNames,
+  getMonthNames,
+  getMonthParts,
+  getMonthPartsKey,
+  getHourDates,
+  getRelativeTimeNames,
+  isDateParts,
+} from './date/helpers';
+import Cache from './cache';
+import { type DateRangeSource, DateRange } from './date/range';
+import { defaultLocales } from './defaults';
+import {
+  isString,
+  isNumber,
+  isDate,
+  isObject,
+  has,
+  pick,
+  clamp,
+  defaultsDeep,
+} from './helpers';
+
+export interface LocaleConfig {
+  id: string;
+  firstDayOfWeek: number;
+  masks: any;
+  monthCacheSize: number;
+  pageCacheSize: number;
+}
+
+const DEFAULT_MONTH_CACHE_SIZE = 12;
+const DEFAULT_PAGE_CACHE_SIZE = 5;
+
+export function resolveConfig(
+  config: string | Partial<LocaleConfig> | undefined,
+  locales: any,
+) {
+  // Get the detected locale string
+  const detLocale = new Intl.DateTimeFormat().resolvedOptions().locale;
+  // Resolve the locale id
+  let id;
+  if (isString(config)) {
+    id = config;
+  } else if (has(config, 'id')) {
+    id = config!.id;
+  }
+  id = (id || detLocale).toLowerCase();
+  const localeKeys = Object.keys(locales);
+  const validKey = (k: string) => localeKeys.find(lk => lk.toLowerCase() === k);
+  id = validKey(id) || validKey(id.substring(0, 2)) || detLocale;
+  // Add fallback and spread default locale to prevent repetitive update loops
+  const defLocale: LocaleConfig = {
+    ...locales['en-IE'],
+    ...locales[id],
+    id,
+    monthCacheSize: DEFAULT_MONTH_CACHE_SIZE,
+    pageCacheSize: DEFAULT_PAGE_CACHE_SIZE,
+  };
+  // Assign or merge defaults with provided config
+  const result: LocaleConfig = isObject(config)
+    ? defaultsDeep(config, defLocale)
+    : defLocale;
+  // Return resolved config
+  return result;
+}
+
+export default class Locale {
+  id: any;
+  daysInWeek: number;
+  firstDayOfWeek: DayOfWeek;
+  masks: any;
+  timezone: string | undefined;
+  hourLabels: string[];
+  dayNames: string[];
+  dayNamesShort: string[];
+  dayNamesShorter: string[];
+  dayNamesNarrow: string[];
+  monthNames: string[];
+  monthNamesShort: string[];
+  relativeTimeNames: TimeNames;
+  amPm: [string, string] = ['am', 'pm'];
+  monthCache: Cache<MonthParts>;
+  pageCache: Cache<CachedPage>;
+
+  constructor(
+    config: Partial<LocaleConfig> | string | undefined = undefined,
+    timezone?: string,
+  ) {
+    const { id, firstDayOfWeek, masks, monthCacheSize, pageCacheSize } =
+      resolveConfig(config, defaultLocales.value);
+    this.monthCache = new Cache(
+      monthCacheSize,
+      getMonthPartsKey,
+      getMonthParts,
+    );
+    this.pageCache = new Cache(pageCacheSize, getPageKey, getCachedPage);
+    this.id = id;
+    this.daysInWeek = daysInWeek;
+    this.firstDayOfWeek = clamp(firstDayOfWeek, 1, daysInWeek) as DayOfWeek;
+    this.masks = masks;
+    this.timezone = timezone || undefined;
+    this.hourLabels = this.getHourLabels();
+    this.dayNames = getDayNames('long', this.id);
+    this.dayNamesShort = getDayNames('short', this.id);
+    this.dayNamesShorter = this.dayNamesShort.map(s => s.substring(0, 2));
+    this.dayNamesNarrow = getDayNames('narrow', this.id);
+    this.monthNames = getMonthNames('long', this.id);
+    this.monthNamesShort = getMonthNames('short', this.id);
+    this.relativeTimeNames = getRelativeTimeNames(this.id);
+  }
+
+  formatDate(date: Date, masks: string | string[]) {
+    return formatDate(date, masks, this);
+  }
+
+  parseDate(dateString: string, mask: string | string[]) {
+    return parseDate(dateString, mask, this);
+  }
+
+  toDate(
+    d: DateSource | Partial<SimpleDateParts>,
+    opts: Partial<DateOptions> = {},
+  ): Date {
+    const nullDate = new Date(NaN);
+    let result = nullDate;
+    const { fillDate, mask, patch, rules } = opts;
+    if (isNumber(d)) {
+      opts.type = 'number';
+      result = new Date(+d);
+    } else if (isString(d)) {
+      opts.type = 'string';
+      result = d ? parseDate(d, mask || 'iso', this) : nullDate;
+    } else if (isDate(d)) {
+      opts.type = 'date';
+      result = new Date(d.getTime());
+    } else if (isDateParts(d)) {
+      opts.type = 'object';
+      result = this.getDateFromParts(d);
+    }
+    // Patch parts or apply rules if needed
+    if (result && (patch || rules)) {
+      let parts = this.getDateParts(result);
+      // Patch date parts
+      if (patch && fillDate != null) {
+        const fillParts = this.getDateParts(this.toDate(fillDate));
+        parts = this.getDateParts(
+          this.toDate({ ...fillParts, ...pick(parts, DatePatchKeys[patch]) }),
+        );
+      }
+      // Apply date part rules
+      if (rules) {
+        parts = applyRulesForDateParts(parts, rules);
+      }
+      result = this.getDateFromParts(parts);
+    }
+    return result || nullDate;
+  }
+
+  toDateOrNull(
+    d: DateSource | Partial<SimpleDateParts>,
+    opts: Partial<DateOptions> = {},
+  ): Date | null {
+    const dte = this.toDate(d, opts);
+    return isNaN(dte.getTime()) ? null : dte;
+  }
+
+  fromDate(date: Date | null, { type, mask }: Partial<DateOptions> = {}) {
+    switch (type) {
+      case 'number':
+        return date ? date.getTime() : NaN;
+      case 'string':
+        return date ? this.formatDate(date, mask || 'iso') : '';
+      case 'object':
+        return date ? this.getDateParts(date) : null;
+      default:
+        return date ? new Date(date) : null;
+    }
+  }
+
+  range(source: DateRangeSource) {
+    return DateRange.from(source, this);
+  }
+
+  ranges(ranges: DateRangeSource | DateRangeSource[]) {
+    return DateRange.fromMany(ranges, this);
+  }
+
+  getDateParts(date: Date) {
+    return getDateParts(date, this);
+  }
+
+  getDateFromParts(parts: Partial<SimpleDateParts>) {
+    return getDateFromParts(parts, this.timezone);
+  }
+
+  getDateFromParams(
+    year: number,
+    month: number,
+    day: number,
+    hours: number,
+    minutes: number,
+    seconds: number,
+    milliseconds: number,
+  ) {
+    return this.getDateFromParts({
+      year,
+      month,
+      day,
+      hours,
+      minutes,
+      seconds,
+      milliseconds,
+    });
+  }
+
+  getPage(config: PageConfig) {
+    const cachedPage = this.pageCache.getOrSet(config, this);
+    return getPage(config, cachedPage);
+  }
+
+  getMonthParts(month: number, year: number) {
+    const { firstDayOfWeek } = this;
+    return this.monthCache.getOrSet(month, year, firstDayOfWeek);
+  }
+
+  getThisMonthParts() {
+    const date = new Date();
+    return this.getMonthParts(
+      <MonthInYear>(date.getMonth() + 1),
+      date.getFullYear(),
+    );
+  }
+
+  getPrevMonthParts(month: number, year: number) {
+    if (month === 1) return this.getMonthParts(12, year - 1);
+    return this.getMonthParts(month - 1, year);
+  }
+
+  getNextMonthParts(month: number, year: number) {
+    if (month === 12) return this.getMonthParts(1, year + 1);
+    return this.getMonthParts(month + 1, year);
+  }
+
+  getHourLabels() {
+    return getHourDates().map(d => {
+      return this.formatDate(d, this.masks.hours);
+    });
+  }
+
+  getDayId(date: Date) {
+    return this.formatDate(date, 'YYYY-MM-DD');
+  }
+}