@lekoala/date-picker 0.1.0

package/src/date-range.js

@@ -0,0 +1,172 @@
+import { compareDates, isDate } from "./date.js";
+
+/** @typedef {{start:string, end:string}} DateRange */
+
+/**
+ * Validate and normalize a range for display.
+ *
+ * - `null` and `{ start: "", end: "" }` reset the range;
+ * - `start` and `end` are canonical `YYYY-MM-DD` strings;
+ * - `end` may be empty (range in progress);
+ * - the range is never reordered here: an inversion or an `end` without a
+ *   `start` is a programming error and is rejected.
+ * @param {{start?:string, end?:string}|null|undefined} range
+ * @returns {DateRange}
+ */
+export function normalizeRange(range) {
+  if (range == null) return { start: "", end: "" };
+  if (typeof range !== "object") throw new TypeError("highlightedRange expects { start, end }");
+  const { start = "", end = "" } = range;
+  if (start && !isDate(start)) throw new TypeError(`Invalid range start: ${start}`);
+  if (end && !isDate(end)) throw new TypeError(`Invalid range end: ${end}`);
+  if (!start && end) throw new TypeError("highlightedRange cannot define an end without a start");
+  if (start && end && compareDates(end, start) < 0)
+    throw new TypeError("highlightedRange must be ordered; start must be on or before end");
+  return { start, end };
+}
+
+/**
+ * Position of one day within a displayable range.
+ *
+ * A single-day range (`start === end`) cannot be both endpoints at once, so it
+ * returns `"single"`; the caller renders it as both `data-range-start` and
+ * `data-range-end`. A start-only range (in-progress) returns `"start"`.
+ * @param {string} date
+ * @param {DateRange|null|undefined} range
+ * @returns {"" | "start" | "in" | "end" | "single"}
+ */
+export function rangePosition(date, range) {
+  if (!range || !isDate(date)) return "";
+  const { start, end } = range;
+  if (!start || !isDate(start)) return "";
+  if (start === date) return end ? (end === date ? "single" : "start") : "start";
+  if (end && end === date) return "end";
+  if (end && compareDates(date, start) >= 0 && compareDates(date, end) <= 0) return "in";
+  return "";
+}
+
+/**
+ * Pure two-bound state machine for the shared-calendar range picker. Covers
+ * start/end state and the active-endpoint transition rules; it knows nothing
+ * about DOM, popups or async availability.
+ *
+ * Interaction contract (U9):
+ * - opening through a field targets that bound;
+ * - a pick outside a complete range extends the corresponding bound;
+ * - otherwise activating through `end` refuses a date before `start`;
+ * - activating through `start` commits `start`, moves the active endpoint to
+ *   `end` and leaves the popup open for the second selection.
+ *
+ * The business range may be temporarily incomplete or inverted; it is the
+ * coordinator's job to forward only a displayable range to
+ * `calendar.highlightedRange`.
+ */
+export class DateRangeController {
+  constructor() {
+    /** @type {"" | "start" | "end"} */
+    this.activeEndpoint = "";
+    this.start = "";
+    this.end = "";
+  }
+
+  /** @returns {{start:string, end:string}} */
+  get range() {
+    return { start: this.start, end: this.end };
+  }
+
+  /** Whether both bounds exist and are ordered (start <= end). */
+  get complete() {
+    return Boolean(this.start && this.end && compareDates(this.end, this.start) >= 0);
+  }
+
+  /** @param {"" | "start" | "end"} endpoint */
+  focus(endpoint) {
+    this.activeEndpoint = endpoint;
+  }
+
+  /**
+   * Process one grid activation through the active endpoint.
+   *
+   * `editable(bound)` reports whether a bound can receive a user pick. It
+   * guards every commit and the `start -> end` transition: when the next bound
+   * is uneditable the returned result carries `close: true` instead of leaving
+   * the popup targeting a bound that can never change. `status: "complete"`
+   * stays reserved for an actually ordered pair.
+   * @param {string} date
+   * @param {(bound: "start" | "end") => boolean} [editable]
+   * @returns {{status: "pending" | "complete" | "refused", endpoint: "start" | "end", close?: boolean}}
+   */
+  activate(date, editable = () => true) {
+    if (!isDate(date)) throw new TypeError(`Invalid range activation: ${date}`);
+    if (this.complete && (compareDates(date, this.start) < 0 || compareDates(date, this.end) > 0)) {
+      const endpoint = compareDates(date, this.start) < 0 ? "start" : "end";
+      if (!editable(endpoint)) return { status: "refused", endpoint };
+      this[endpoint] = date;
+      this.activeEndpoint = endpoint;
+      return { status: "complete", endpoint };
+    }
+    if (this.activeEndpoint === "end") {
+      if (this.start && compareDates(date, this.start) < 0) {
+        return { status: "refused", endpoint: "end" };
+      }
+      if (!editable("end")) return { status: "refused", endpoint: "end" };
+      this.end = date;
+      return { status: this.start ? "complete" : "pending", endpoint: "end" };
+    }
+    if (!editable("start")) return { status: "refused", endpoint: "start" };
+    this.start = date;
+    if (!editable("end")) {
+      // The range stays incomplete but must close: the next bound cannot
+      // receive the complementary pick.
+      return { status: "pending", endpoint: "start", close: true };
+    }
+    this.activeEndpoint = "end";
+    return { status: "pending", endpoint: "start" };
+  }
+}
+
+/** @param {string} a @param {string} b */
+function later(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return compareDates(a, b) >= 0 ? a : b;
+}
+
+/** @param {string} a @param {string} b */
+function earlier(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return compareDates(a, b) <= 0 ? a : b;
+}
+
+/**
+ * Link two date pickers without teaching either picker about its sibling.
+ * Effective constraint: end >= start and start <= end.
+ * @param {import("./date-picker.js").DatePickerElement} start
+ * @param {import("./date-picker.js").DatePickerElement} end
+ * @returns {() => void}
+ */
+export function linkDateRange(start, end) {
+  const baseStartMax = start.max;
+  const baseEndMin = end.min;
+
+  const sync = () => {
+    const startValue = typeof start.value === "string" && isDate(start.value) ? start.value : "";
+    const endValue = typeof end.value === "string" && isDate(end.value) ? end.value : "";
+    end.min = later(baseEndMin, startValue);
+    start.max = earlier(baseStartMax, endValue);
+    void start.validate();
+    void end.validate();
+  };
+
+  start.addEventListener("valuechange", sync);
+  end.addEventListener("valuechange", sync);
+  sync();
+
+  return () => {
+    start.removeEventListener("valuechange", sync);
+    end.removeEventListener("valuechange", sync);
+    start.max = baseStartMax;
+    end.min = baseEndMin;
+  };
+}

package/src/date.js

@@ -0,0 +1,203 @@
+const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const MONTH_RE = /^(\d{4})-(\d{2})$/;
+
+/** @param {number} year */
+export function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
+/** @param {number} year @param {number} month */
+export function daysInMonth(year, month) {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+
+/**
+ * Parse one canonical civil date.
+ * @param {string} value
+ * @returns {{year:number, month:number, day:number} | null}
+ */
+export function parseDate(value) {
+  const match = DATE_RE.exec(String(value || ""));
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || year > 9999 || month < 1 || month > 12) return null;
+  if (day < 1 || day > daysInMonth(year, month)) return null;
+  return { year, month, day };
+}
+
+/** @param {string} value */
+export function isDate(value) {
+  return parseDate(value) !== null;
+}
+
+/**
+ * Normalize YYYY-MM or YYYY-MM-DD to YYYY-MM.
+ * @param {string} value
+ * @returns {string}
+ */
+export function monthKey(value) {
+  const text = String(value || "");
+  const monthMatch = MONTH_RE.exec(text);
+  if (monthMatch) {
+    const month = Number(monthMatch[2]);
+    if (month >= 1 && month <= 12) return `${monthMatch[1]}-${String(month).padStart(2, "0")}`;
+  }
+  const parsed = parseDate(text);
+  if (!parsed) throw new TypeError(`Invalid civil date/month: ${value}`);
+  return `${String(parsed.year).padStart(4, "0")}-${String(parsed.month).padStart(2, "0")}`;
+}
+
+/** @param {number} year @param {number} month @param {number} day */
+export function toISODate(year, month, day) {
+  const value = `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  if (!isDate(value)) throw new TypeError(`Invalid civil date: ${value}`);
+  return value;
+}
+
+/** @param {{year:number, month:number, day:number}} parts */
+function toUTCDate(parts) {
+  const date = new Date(0);
+  date.setUTCHours(12, 0, 0, 0);
+  date.setUTCFullYear(parts.year, parts.month - 1, parts.day);
+  return date;
+}
+
+/** @param {Date} date */
+function fromUTCDate(date) {
+  return toISODate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+}
+
+/** @param {string} value */
+export function toIntlDate(value) {
+  const parsed = parseDate(value);
+  if (!parsed) throw new TypeError(`Invalid civil date: ${value}`);
+  return toUTCDate(parsed);
+}
+
+/** @param {string} a @param {string} b */
+export function compareDates(a, b) {
+  if (!isDate(a) || !isDate(b)) throw new TypeError("compareDates() expects YYYY-MM-DD values");
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+
+/** @param {string} value @param {number} amount */
+export function addDays(value, amount) {
+  const parsed = parseDate(value);
+  if (!parsed || !Number.isInteger(amount))
+    throw new TypeError("addDays() expects a date and integer amount");
+  const date = toUTCDate(parsed);
+  date.setUTCDate(date.getUTCDate() + amount);
+  return fromUTCDate(date);
+}
+
+/** @param {string} value @param {number} amount */
+export function addMonths(value, amount) {
+  const parsed = parseDate(value);
+  if (!parsed || !Number.isInteger(amount))
+    throw new TypeError("addMonths() expects a date and integer amount");
+  const absoluteMonth = parsed.year * 12 + (parsed.month - 1) + amount;
+  const year = Math.floor(absoluteMonth / 12);
+  const monthIndex = ((absoluteMonth % 12) + 12) % 12;
+  const month = monthIndex + 1;
+  const day = Math.min(parsed.day, daysInMonth(year, month));
+  return toISODate(year, month, day);
+}
+
+/** @param {string} value @param {number} amount */
+export function addYears(value, amount) {
+  const parsed = parseDate(value);
+  if (!parsed || !Number.isInteger(amount))
+    throw new TypeError("addYears() expects a date and integer amount");
+  const year = parsed.year + amount;
+  const day = Math.min(parsed.day, daysInMonth(year, parsed.month));
+  return toISODate(year, parsed.month, day);
+}
+
+/** @param {string} month @param {number} amount */
+export function shiftMonth(month, amount) {
+  const start = `${monthKey(month)}-01`;
+  return monthKey(addMonths(start, amount));
+}
+
+/** @param {string} value */
+export function startOfMonth(value) {
+  return `${monthKey(value)}-01`;
+}
+
+/** @param {string} value */
+export function endOfMonth(value) {
+  const parsed = parseDate(`${monthKey(value)}-01`);
+  if (!parsed) throw new TypeError(`Invalid month: ${value}`);
+  return toISODate(parsed.year, parsed.month, daysInMonth(parsed.year, parsed.month));
+}
+
+/** 0=Sunday ... 6=Saturday. @param {string} value */
+export function dayOfWeek(value) {
+  const parsed = parseDate(value);
+  if (!parsed) throw new TypeError(`Invalid civil date: ${value}`);
+  return toUTCDate(parsed).getUTCDay();
+}
+
+/** @param {string} value @param {number} firstDay */
+export function startOfWeek(value, firstDay = 1) {
+  if (!Number.isInteger(firstDay) || firstDay < 0 || firstDay > 6)
+    throw new RangeError("firstDay must be 0..6");
+  const offset = (dayOfWeek(value) - firstDay + 7) % 7;
+  return addDays(value, -offset);
+}
+
+/** @param {string} value @param {number} firstDay */
+export function endOfWeek(value, firstDay = 1) {
+  return addDays(startOfWeek(value, firstDay), 6);
+}
+
+/**
+ * True civil weeks covering the anchor month: 4..6 full rows, never padded.
+ * @param {string} value YYYY-MM or YYYY-MM-DD
+ * @param {{firstDay?: number}} [options]
+ */
+export function getMonthWeeks(value, options = {}) {
+  const firstDay = options.firstDay ?? 1;
+  const start = startOfWeek(startOfMonth(value), firstDay);
+  const end = endOfWeek(endOfMonth(value), firstDay);
+  /** @type {string[][]} */
+  const weeks = [];
+  let cursor = start;
+  while (compareDates(cursor, end) <= 0) {
+    const week = [];
+    for (let i = 0; i < 7; i++) week.push(addDays(cursor, i));
+    weeks.push(week);
+    cursor = addDays(cursor, 7);
+  }
+  return weeks;
+}
+
+/** @param {string} value @param {string} [min] @param {string} [max] */
+export function clampDate(value, min = "", max = "") {
+  if (!isDate(value)) throw new TypeError(`Invalid civil date: ${value}`);
+  if (min && compareDates(value, min) < 0) return min;
+  if (max && compareDates(value, max) > 0) return max;
+  return value;
+}
+
+/** Local civil date; no timezone conversion of the selected date model. */
+export function todayISO() {
+  const now = new Date();
+  return toISODate(now.getFullYear(), now.getMonth() + 1, now.getDate());
+}
+
+/** ISO-8601 week number. @param {string} value */
+export function isoWeekNumber(value) {
+  const parsed = parseDate(value);
+  if (!parsed) throw new TypeError(`Invalid civil date: ${value}`);
+  const date = toUTCDate(parsed);
+  const day = date.getUTCDay() || 7;
+  date.setUTCDate(date.getUTCDate() + 4 - day);
+  const yearStart = new Date(0);
+  yearStart.setUTCHours(12, 0, 0, 0);
+  yearStart.setUTCFullYear(date.getUTCFullYear(), 0, 1);
+  return Math.ceil(((date.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+}

package/src/define.js

@@ -0,0 +1,9 @@
+import { DateCalendarElement } from "./date-calendar.js";
+import { DatePickerElement } from "./date-picker.js";
+
+export function defineDatePicker() {
+  if (!customElements.get("date-calendar")) customElements.define("date-calendar", DateCalendarElement);
+  if (!customElements.get("date-picker")) customElements.define("date-picker", DatePickerElement);
+}
+
+defineDatePicker();

package/src/index.js

@@ -0,0 +1,15 @@
+export { CalendarModel } from "./calendar-model.js";
+export * as dates from "./date.js";
+export { DateCalendarElement } from "./date-calendar.js";
+export { DatePickerElement } from "./date-picker.js";
+export { linkDateRange, normalizeRange, rangePosition } from "./date-range.js";
+export {
+  createDateAdapter,
+  formatLongDate,
+  formatMonthYear,
+  monthNames,
+  resolveLocale,
+  weekdayNames,
+} from "./intl.js";
+export { DEFAULT_MESSAGES, getDefaultMessages, setDefaultMessages } from "./messages.js";
+export { createFetchSource, normalizeDateStates } from "./source.js";

package/src/intl.js

@@ -0,0 +1,155 @@
+import { isDate, parseDate, toIntlDate, toISODate } from "./date.js";
+
+const BIDI = /[\u200e\u200f\u061c\u202a-\u202e\u2066-\u2069]/g;
+
+/** @param {string} [locale] */
+export function resolveLocale(locale = "") {
+  if (locale) return locale;
+  if (typeof document !== "undefined" && document.documentElement.lang) return document.documentElement.lang;
+  if (typeof navigator !== "undefined" && navigator.language) return navigator.language;
+  return "en-US";
+}
+
+/** @param {string} locale */
+function digitMap(locale) {
+  const formatter = new Intl.NumberFormat(locale, { useGrouping: false });
+  const map = new Map();
+  for (let i = 0; i <= 9; i++) map.set(formatter.format(i), String(i));
+  return map;
+}
+
+/** @param {string} text @param {string} locale */
+function normalizeDigits(text, locale) {
+  let result = String(text || "")
+    .replace(BIDI, "")
+    .trim();
+  for (const [local, ascii] of digitMap(locale)) result = result.split(local).join(ascii);
+  return result;
+}
+
+/** @param {string} value @param {string} [locale] */
+export function formatLongDate(value, locale = "") {
+  const resolved = resolveLocale(locale);
+  return new Intl.DateTimeFormat(resolved, {
+    calendar: "gregory",
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: "UTC",
+  }).format(toIntlDate(value));
+}
+
+/** @param {string} value @param {string} [locale] */
+export function formatMonthYear(value, locale = "") {
+  const resolved = resolveLocale(locale);
+  return new Intl.DateTimeFormat(resolved, {
+    calendar: "gregory",
+    year: "numeric",
+    month: "long",
+    timeZone: "UTC",
+  }).format(toIntlDate(`${value.slice(0, 7)}-15`));
+}
+
+/** @param {string} [locale] @param {"long"|"short"} [style] */
+export function monthNames(locale = "", style = "long") {
+  const resolved = resolveLocale(locale);
+  const formatter = new Intl.DateTimeFormat(resolved, { calendar: "gregory", month: style, timeZone: "UTC" });
+  return Array.from({ length: 12 }, (_, index) =>
+    formatter.format(toIntlDate(`2026-${String(index + 1).padStart(2, "0")}-15`)),
+  );
+}
+
+/**
+ * @param {string} [locale]
+ * @param {number} [firstDay]
+ * @param {"long"|"short"|"narrow"} [style]
+ */
+export function weekdayNames(locale = "", firstDay = 1, style = "short") {
+  const resolved = resolveLocale(locale);
+  const formatter = new Intl.DateTimeFormat(resolved, {
+    calendar: "gregory",
+    weekday: style,
+    timeZone: "UTC",
+  });
+  // 2026-01-04 is a Sunday.
+  const sunday = toIntlDate("2026-01-04");
+  return Array.from({ length: 7 }, (_, index) => {
+    const date = new Date(sunday);
+    date.setUTCDate(sunday.getUTCDate() + ((firstDay + index) % 7));
+    return formatter.format(date);
+  });
+}
+
+/** @param {string} value */
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Localized, editable numeric date adapter. The canonical value remains YYYY-MM-DD.
+ * @param {string} [locale]
+ */
+export function createDateAdapter(locale = "") {
+  const resolved = resolveLocale(locale);
+  const formatter = new Intl.DateTimeFormat(resolved, {
+    calendar: "gregory",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: "UTC",
+  });
+  const sample = toIntlDate("2006-11-22");
+  const parts = formatter.formatToParts(sample).filter((part) => part.type !== "literal" || part.value);
+  const order = parts.filter((part) => ["day", "month", "year"].includes(part.type)).map((part) => part.type);
+  const placeholder = parts
+    .map((part) => {
+      if (part.type === "day") return "DD";
+      if (part.type === "month") return "MM";
+      if (part.type === "year") return "YYYY";
+      return part.value.replace(BIDI, "");
+    })
+    .join("");
+  const pattern = parts
+    .map((part) => {
+      if (part.type === "day" || part.type === "month") return "(\\d{1,2})";
+      if (part.type === "year") return "(\\d{4})";
+      const literal = normalizeDigits(part.value, resolved).replace(/\s+/g, " ");
+      return escapeRegExp(literal).replace(/\\ /g, "\\s*");
+    })
+    .join("");
+  const regex = new RegExp(`^\\s*${pattern}\\s*$`);
+
+  return {
+    locale: resolved,
+    placeholder,
+    /** @param {string} value */
+    format(value) {
+      if (!isDate(value)) return "";
+      return formatter.format(toIntlDate(value));
+    },
+    /** @param {string} text @returns {string} */
+    parse(text) {
+      const normalized = normalizeDigits(text, resolved);
+      if (isDate(normalized)) return normalized;
+      const match = regex.exec(normalized);
+      if (!match) return "";
+      /** @type {Record<string, number>} */
+      const values = {};
+      order.forEach((type, index) => {
+        values[type] = Number(match[index + 1]);
+      });
+      if (!values.year || !values.month || !values.day) return "";
+      try {
+        return toISODate(values.year, values.month, values.day);
+      } catch {
+        return "";
+      }
+    },
+  };
+}
+
+/** @param {string} value */
+export function dateParts(value) {
+  return parseDate(value);
+}

package/src/locales/ar.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "اختيار تاريخ",
+  changeDate: "تغيير التاريخ",
+  previousMonth: "الشهر السابق",
+  nextMonth: "الشهر التالي",
+  month: "الشهر",
+  year: "السنة",
+  calendar: "اختيار تاريخ",
+  unavailable: "غير متاح",
+  invalidDate: "أدخل تاريخًا صالحًا",
+  unavailableDate: "هذا التاريخ غير متاح",
+  formatHint: "التنسيق",
+  week: "الأسبوع",
+  rangeStart: "بداية النطاق",
+  rangeInRange: "داخل النطاق",
+  rangeEnd: "نهاية النطاق",
+  rangeSingle: "نطاق يوم واحد",
+  rangeOrderStart: "يجب أن تكون البداية قبل النهاية أو مساوية لها",
+  rangeOrderEnd: "يجب أن تكون النهاية بعد البداية أو مساوية لها",
+};

package/src/locales/de.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "Datum auswählen",
+  changeDate: "Datum ändern",
+  previousMonth: "Vorheriger Monat",
+  nextMonth: "Nächster Monat",
+  month: "Monat",
+  year: "Jahr",
+  calendar: "Datum auswählen",
+  unavailable: "Nicht verfügbar",
+  invalidDate: "Gültiges Datum eingeben",
+  unavailableDate: "Dieses Datum ist nicht verfügbar",
+  formatHint: "Format",
+  week: "Woche",
+  rangeStart: "Bereichsbeginn",
+  rangeInRange: "Im Bereich",
+  rangeEnd: "Bereichsende",
+  rangeSingle: "Eintägiger Bereich",
+  rangeOrderStart: "Start muss vor oder am Ende liegen",
+  rangeOrderEnd: "Ende muss nach oder am Start liegen",
+};

package/src/locales/en.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "Choose date",
+  changeDate: "Change date",
+  previousMonth: "Previous month",
+  nextMonth: "Next month",
+  month: "Month",
+  year: "Year",
+  calendar: "Choose a date",
+  unavailable: "Unavailable",
+  invalidDate: "Enter a valid date",
+  unavailableDate: "This date is unavailable",
+  formatHint: "Format",
+  week: "Week",
+  rangeStart: "Range start",
+  rangeInRange: "Inside range",
+  rangeEnd: "Range end",
+  rangeSingle: "Range of one day",
+  rangeOrderStart: "Start must be on or before end",
+  rangeOrderEnd: "End must be on or after start",
+};

package/src/locales/es.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "Elegir fecha",
+  changeDate: "Cambiar fecha",
+  previousMonth: "Mes anterior",
+  nextMonth: "Mes siguiente",
+  month: "Mes",
+  year: "Año",
+  calendar: "Elegir una fecha",
+  unavailable: "No disponible",
+  invalidDate: "Introduce una fecha válida",
+  unavailableDate: "Esta fecha no está disponible",
+  formatHint: "Formato",
+  week: "Semana",
+  rangeStart: "Inicio del rango",
+  rangeInRange: "Dentro del rango",
+  rangeEnd: "Fin del rango",
+  rangeSingle: "Rango de un día",
+  rangeOrderStart: "El inicio debe ser anterior o igual al final",
+  rangeOrderEnd: "El final debe ser posterior o igual al inicio",
+};

package/src/locales/fr.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "Choisir une date",
+  changeDate: "Modifier la date",
+  previousMonth: "Mois précédent",
+  nextMonth: "Mois suivant",
+  month: "Mois",
+  year: "Année",
+  calendar: "Choisir une date",
+  unavailable: "Indisponible",
+  invalidDate: "Saisissez une date valide",
+  unavailableDate: "Cette date n’est pas disponible",
+  formatHint: "Format",
+  week: "Semaine",
+  rangeStart: "Début de la plage",
+  rangeInRange: "Dans la plage",
+  rangeEnd: "Fin de la plage",
+  rangeSingle: "Plage d’un jour",
+  rangeOrderStart: "Le début doit être antérieur ou égal à la fin",
+  rangeOrderEnd: "La fin doit être postérieure ou égale au début",
+};

package/src/locales/hi.js

@@ -0,0 +1,20 @@
+export default {
+  chooseDate: "तारीख़ चुनें",
+  changeDate: "तारीख़ बदलें",
+  previousMonth: "पिछला महीना",
+  nextMonth: "अगला महीना",
+  month: "महीना",
+  year: "वर्ष",
+  calendar: "कोई तारीख़ चुनें",
+  unavailable: "अनुपलब्ध",
+  invalidDate: "एक मान्य तारीख़ दर्ज करें",
+  unavailableDate: "यह तारीख़ उपलब्ध नहीं है",
+  formatHint: "प्रारूप",
+  week: "सप्ताह",
+  rangeStart: "सीमा आरंभ",
+  rangeInRange: "सीमा के अंदर",
+  rangeEnd: "सीमा अंत",
+  rangeSingle: "एक दिन की सीमा",
+  rangeOrderStart: "प्रारंभ अंत से पहले या उसके बराबर होना चाहिए",
+  rangeOrderEnd: "अंत प्रारंभ के बाद या उसके बराबर होना चाहिए",
+};