@gobrand/calendar-core 0.0.3

package/dist/index.js

@@ -0,0 +1,651 @@
+// src/utils.ts
+import { Temporal } from "@js-temporal/polyfill";
+function functionalUpdate(updater, input) {
+  return typeof updater === "function" ? updater(input) : updater;
+}
+function createCalendarAccessor(accessor) {
+  return accessor;
+}
+function nextMonth(month) {
+  return month.add({ months: 1 });
+}
+function previousMonth(month) {
+  return month.subtract({ months: 1 });
+}
+function nextWeek(date) {
+  return date.add({ weeks: 1 });
+}
+function previousWeek(date) {
+  return date.subtract({ weeks: 1 });
+}
+function nextDay(date) {
+  return date.add({ days: 1 });
+}
+function previousDay(date) {
+  return date.subtract({ days: 1 });
+}
+function goToToday() {
+  const today = Temporal.Now.plainDateISO();
+  return { year: today.year, month: today.month };
+}
+function getWeekdays(weekStartsOn = 1, locale = "en-US", format = "short") {
+  const referenceDate = Temporal.PlainDate.from("2023-01-02");
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const offset = (weekStartsOn - 1 + i + 7) % 7;
+    const date = referenceDate.add({ days: offset });
+    days.push(date.toLocaleString(locale, { weekday: format }));
+  }
+  return days;
+}
+function getMonthName(month, locale = "en-US") {
+  return month.toPlainDate({ day: 1 }).toLocaleString(locale, { month: "long" });
+}
+function formatTime(time, locale = "en-US") {
+  const date = Temporal.PlainDate.from("2023-01-01");
+  const dateTime = date.toPlainDateTime(time);
+  return dateTime.toLocaleString(locale, { hour: "numeric", minute: "2-digit" });
+}
+function getTimeSlotHeight(slotDuration, hourHeight) {
+  return slotDuration / 60 * hourHeight;
+}
+function getEventPosition(eventStart, eventEnd, dayStart, hourHeight) {
+  const startTime = eventStart.toPlainTime();
+  const endTime = eventEnd.toPlainTime();
+  const startMinutes = startTime.hour * 60 + startTime.minute;
+  const endMinutes = endTime.hour * 60 + endTime.minute;
+  const dayStartMinutes = dayStart * 60;
+  const top = (startMinutes - dayStartMinutes) / 60 * hourHeight;
+  const height = (endMinutes - startMinutes) / 60 * hourHeight;
+  return { top, height };
+}
+function convertToTimezone(dateTime, timeZone) {
+  return dateTime.withTimeZone(timeZone);
+}
+function getTimezoneOffset(dateTime) {
+  return dateTime.offsetNanoseconds / 36e11 >= 0 ? `+${Math.floor(dateTime.offsetNanoseconds / 36e11)}` : `${Math.floor(dateTime.offsetNanoseconds / 36e11)}`;
+}
+function createZonedDateTime(date, time, timeZone) {
+  return date.toZonedDateTime({ timeZone, plainTime: time });
+}
+function getCurrentTimeZone() {
+  return Temporal.Now.timeZoneId();
+}
+function getMonthRange(timeZone = getCurrentTimeZone(), weekStartsOn = 1) {
+  const today = Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  const firstOfMonth = today.with({ day: 1 });
+  const lastOfMonth = today.with({ day: today.daysInMonth });
+  const startDayOfWeek = firstOfMonth.dayOfWeek;
+  const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+  const start = firstOfMonth.subtract({ days: daysToSubtract });
+  const endDayOfWeek = lastOfMonth.dayOfWeek;
+  const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+  const end = lastOfMonth.add({ days: daysToAdd });
+  return { start, end };
+}
+function getWeekRange(timeZone = getCurrentTimeZone(), weekStartsOn = 1) {
+  const today = Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  const dayOfWeek = today.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const start = today.subtract({ days: daysToSubtract });
+  const end = start.add({ days: 6 });
+  return { start, end };
+}
+function getDayRange(timeZone = getCurrentTimeZone()) {
+  const today = Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  return { start: today, end: today };
+}
+
+// src/utils/buildMonth.ts
+import { Temporal as Temporal2 } from "@js-temporal/polyfill";
+function buildMonth(year, month, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const today = options?.today ?? Temporal2.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const yearMonth = Temporal2.PlainYearMonth.from({ year, month });
+  const firstOfMonth = yearMonth.toPlainDate({ day: 1 });
+  const lastOfMonth = yearMonth.toPlainDate({ day: yearMonth.daysInMonth });
+  const itemsByDate = /* @__PURE__ */ new Map();
+  if (accessor) {
+    for (const item of data) {
+      const date = accessor.getDate(item);
+      const key = date.toString();
+      const existing = itemsByDate.get(key) ?? [];
+      itemsByDate.set(key, [...existing, item]);
+    }
+  }
+  let startDate = firstOfMonth;
+  const firstDayOfWeek = firstOfMonth.dayOfWeek;
+  const daysToSubtract = (firstDayOfWeek - weekStartsOn + 7) % 7;
+  if (daysToSubtract > 0) {
+    startDate = firstOfMonth.subtract({ days: daysToSubtract });
+  }
+  const weeks = [];
+  let currentDate = startDate;
+  while (currentDate.month !== lastOfMonth.month || currentDate.day <= lastOfMonth.day || weeks.length === 0 || weeks[weeks.length - 1].length < 7) {
+    if (weeks.length === 0 || weeks[weeks.length - 1].length === 7) {
+      weeks.push([]);
+    }
+    const dateKey = currentDate.toString();
+    weeks[weeks.length - 1].push({
+      date: currentDate,
+      isCurrentMonth: currentDate.month === month,
+      isToday: Temporal2.PlainDate.compare(currentDate, today) === 0,
+      items: itemsByDate.get(dateKey) ?? []
+    });
+    currentDate = currentDate.add({ days: 1 });
+    if (weeks.length >= 6 && weeks[weeks.length - 1].length === 7) {
+      break;
+    }
+  }
+  return {
+    weeks,
+    month: yearMonth
+  };
+}
+
+// src/utils/buildWeek.ts
+import { Temporal as Temporal4 } from "@js-temporal/polyfill";
+
+// src/utils/buildDay.ts
+import { Temporal as Temporal3 } from "@js-temporal/polyfill";
+function buildDay(date, options) {
+  const startHour = options?.startHour ?? 0;
+  const endHour = options?.endHour ?? 24;
+  const slotDuration = options?.slotDuration ?? 30;
+  const today = options?.today ?? Temporal3.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const dayItems = [];
+  if (accessor) {
+    for (const item of data) {
+      const itemDate = accessor.getDate(item);
+      if (Temporal3.PlainDate.compare(itemDate, date) === 0) {
+        dayItems.push(item);
+      }
+    }
+  }
+  const timeSlots = [];
+  let currentHour = startHour;
+  let currentMinute = 0;
+  while (currentHour < endHour) {
+    const slotStart = Temporal3.PlainTime.from({ hour: currentHour, minute: currentMinute });
+    let nextMinute = currentMinute + slotDuration;
+    let nextHour = currentHour;
+    if (nextMinute >= 60) {
+      nextHour += Math.floor(nextMinute / 60);
+      nextMinute = nextMinute % 60;
+    }
+    const slotItems = [];
+    if (accessor?.getStart) {
+      for (const item of dayItems) {
+        const itemStart = accessor.getStart(item);
+        const itemTime = itemStart.toPlainTime();
+        const slotEndHour = nextHour >= 24 ? 0 : nextHour;
+        const slotEndMinute = nextHour >= 24 ? 0 : nextMinute;
+        const slotEnd = Temporal3.PlainTime.from({ hour: slotEndHour, minute: slotEndMinute });
+        const isAfterStart = Temporal3.PlainTime.compare(itemTime, slotStart) >= 0;
+        const isBeforeEnd = nextHour >= 24 ? Temporal3.PlainTime.compare(itemTime, slotEnd) > 0 : Temporal3.PlainTime.compare(itemTime, slotEnd) < 0;
+        if (isAfterStart && isBeforeEnd) {
+          slotItems.push(item);
+        }
+      }
+    }
+    timeSlots.push({
+      hour: currentHour,
+      minute: currentMinute,
+      time: slotStart,
+      items: slotItems
+    });
+    currentMinute += slotDuration;
+    if (currentMinute >= 60) {
+      currentHour += Math.floor(currentMinute / 60);
+      currentMinute = currentMinute % 60;
+    }
+  }
+  return {
+    date,
+    isToday: Temporal3.PlainDate.compare(date, today) === 0,
+    timeSlots,
+    items: dayItems
+  };
+}
+
+// src/utils/buildWeek.ts
+function buildWeek(date, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const startHour = options?.startHour;
+  const endHour = options?.endHour;
+  const slotDuration = options?.slotDuration;
+  const today = options?.today ?? Temporal4.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const hasTimeSlots = startHour !== void 0 && endHour !== void 0 && slotDuration !== void 0;
+  const itemsByDate = /* @__PURE__ */ new Map();
+  if (accessor) {
+    for (const item of data) {
+      const date2 = accessor.getDate(item);
+      const key = date2.toString();
+      const existing = itemsByDate.get(key) ?? [];
+      itemsByDate.set(key, [...existing, item]);
+    }
+  }
+  const dayOfWeek = date.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const weekStart = date.subtract({ days: daysToSubtract });
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const currentDate = weekStart.add({ days: i });
+    const dateKey = currentDate.toString();
+    let timeSlots = void 0;
+    if (hasTimeSlots) {
+      const dayView = buildDay(currentDate, {
+        startHour,
+        endHour,
+        slotDuration,
+        today,
+        data,
+        accessor
+      });
+      timeSlots = dayView.timeSlots;
+    }
+    days.push({
+      date: currentDate,
+      isToday: Temporal4.PlainDate.compare(currentDate, today) === 0,
+      items: itemsByDate.get(dateKey) ?? [],
+      timeSlots
+    });
+  }
+  const weekEnd = weekStart.add({ days: 6 });
+  return {
+    days,
+    weekStart,
+    weekEnd
+  };
+}
+
+// src/utils/dateRanges.ts
+import { Temporal as Temporal5 } from "@js-temporal/polyfill";
+function getMonthDateRange(date, timeZone, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const bounds = options?.bounds ?? "calendar";
+  const firstOfMonth = date.with({ day: 1 });
+  const lastOfMonth = date.with({ day: date.daysInMonth });
+  let start;
+  let end;
+  if (bounds === "calendar") {
+    const startDayOfWeek = firstOfMonth.dayOfWeek;
+    const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+    start = firstOfMonth.subtract({ days: daysToSubtract });
+    const endDayOfWeek = lastOfMonth.dayOfWeek;
+    const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+    end = lastOfMonth.add({ days: daysToAdd });
+  } else {
+    start = firstOfMonth;
+    end = lastOfMonth;
+  }
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function getWeekDateRange(date, timeZone, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const dayOfWeek = date.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const start = date.subtract({ days: daysToSubtract });
+  const end = start.add({ days: 6 });
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function getDayDateRange(date, timeZone) {
+  const startZoned = date.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("00:00:00")
+  });
+  const endZoned = date.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal5.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+
+// src/core/calendar.ts
+import { Temporal as Temporal6 } from "@js-temporal/polyfill";
+import { Store } from "@tanstack/store";
+function computeDateRange(view, referenceDate, timeZone, weekStartsOn = 1) {
+  let start;
+  let end;
+  if (view === "month") {
+    const firstOfMonth = referenceDate.with({ day: 1 });
+    const lastOfMonth = referenceDate.with({ day: referenceDate.daysInMonth });
+    const startDayOfWeek = firstOfMonth.dayOfWeek;
+    const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+    start = firstOfMonth.subtract({ days: daysToSubtract });
+    const endDayOfWeek = lastOfMonth.dayOfWeek;
+    const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+    end = lastOfMonth.add({ days: daysToAdd });
+  } else if (view === "week") {
+    const dayOfWeek = referenceDate.dayOfWeek;
+    const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+    start = referenceDate.subtract({ days: daysToSubtract });
+    end = start.add({ days: 6 });
+  } else {
+    start = referenceDate;
+    end = referenceDate;
+  }
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal6.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: Temporal6.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function createCalendar(options) {
+  const configuredViews = Object.keys(options.views);
+  const defaultView = configuredViews[0];
+  const timeZone = options.timeZone || Temporal6.Now.timeZoneId();
+  const monthView = options.views.month;
+  const weekView = options.views.week;
+  const weekStartsOn = monthView?.weekStartsOn ?? weekView?.weekStartsOn ?? 1;
+  const initialReferenceDate = options.state?.referenceDate || Temporal6.Now.plainDateISO();
+  const initialView = options.state?.currentView || defaultView;
+  const initialDateRange = computeDateRange(
+    initialView,
+    initialReferenceDate,
+    timeZone,
+    weekStartsOn
+  );
+  const resolvedOptions = {
+    state: {
+      referenceDate: initialReferenceDate,
+      currentView: initialView,
+      dateRange: initialDateRange
+    },
+    onStateChange: () => {
+    },
+    ...options
+  };
+  let _options = resolvedOptions;
+  const store = new Store({
+    referenceDate: initialReferenceDate,
+    currentView: initialView,
+    dateRange: initialDateRange,
+    ...resolvedOptions.state
+  });
+  const getMonthImpl = () => {
+    const state = store.state;
+    const { year, month } = state.referenceDate;
+    const monthView2 = _options.views.month;
+    if (!monthView2) throw new Error("Month view not configured");
+    return buildMonth(year, month, {
+      weekStartsOn: monthView2.weekStartsOn,
+      data: _options.data,
+      accessor: monthView2.accessor
+    });
+  };
+  const getWeekImpl = () => {
+    const state = store.state;
+    const weekView2 = _options.views.week;
+    if (!weekView2) throw new Error("Week view not configured");
+    return buildWeek(state.referenceDate, {
+      weekStartsOn: weekView2.weekStartsOn,
+      startHour: weekView2.startHour,
+      endHour: weekView2.endHour,
+      slotDuration: weekView2.slotDuration,
+      data: _options.data,
+      accessor: weekView2.accessor
+    });
+  };
+  const getDayImpl = () => {
+    const state = store.state;
+    const dayView = _options.views.day;
+    if (!dayView) throw new Error("Day view not configured");
+    return buildDay(state.referenceDate, {
+      startHour: dayView.startHour,
+      endHour: dayView.endHour,
+      slotDuration: dayView.slotDuration,
+      data: _options.data,
+      accessor: dayView.accessor
+    });
+  };
+  const setStateImpl = (updater) => {
+    const partialState = typeof updater === "function" ? updater(store.state) : updater;
+    const newState = {
+      ...store.state,
+      ...partialState
+    };
+    const currentView = newState.currentView || defaultView;
+    const dateRange = computeDateRange(
+      currentView,
+      newState.referenceDate,
+      timeZone,
+      weekStartsOn
+    );
+    const stateWithDateRange = {
+      ...newState,
+      dateRange
+    };
+    store.setState(() => stateWithDateRange);
+    if (_options.onStateChange) {
+      _options.onStateChange(stateWithDateRange);
+    }
+  };
+  const nextMonthImpl = () => {
+    setStateImpl((old) => {
+      const current = Temporal6.PlainYearMonth.from({
+        year: old.referenceDate.year,
+        month: old.referenceDate.month
+      });
+      const next = nextMonth(current);
+      return {
+        referenceDate: next.toPlainDate({ day: 1 })
+      };
+    });
+  };
+  const previousMonthImpl = () => {
+    setStateImpl((old) => {
+      const current = Temporal6.PlainYearMonth.from({
+        year: old.referenceDate.year,
+        month: old.referenceDate.month
+      });
+      const prev = previousMonth(current);
+      return {
+        referenceDate: prev.toPlainDate({ day: 1 })
+      };
+    });
+  };
+  const nextWeekImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: nextWeek(old.referenceDate)
+    }));
+  };
+  const previousWeekImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: previousWeek(old.referenceDate)
+    }));
+  };
+  const nextDayImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: nextDay(old.referenceDate)
+    }));
+  };
+  const previousDayImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: previousDay(old.referenceDate)
+    }));
+  };
+  const calendar = {
+    getMonth: getMonthImpl,
+    getWeek: getWeekImpl,
+    getDay: getDayImpl,
+    getTitle(view, locales, options2) {
+      switch (view) {
+        case "month": {
+          const month = getMonthImpl();
+          const date = month.month.toPlainDate({ day: 1 });
+          return date.toLocaleString(locales, {
+            month: "long",
+            year: "numeric",
+            ...options2
+          });
+        }
+        case "week": {
+          const week = getWeekImpl();
+          const startOptions = {
+            month: "short",
+            day: "numeric",
+            ...options2
+          };
+          const endOptions = {
+            month: "short",
+            day: "numeric",
+            year: "numeric",
+            ...options2
+          };
+          const start = week.weekStart.toLocaleString(locales, startOptions);
+          const end = week.weekEnd.toLocaleString(locales, endOptions);
+          return `${start} - ${end}`;
+        }
+        case "day": {
+          const day = getDayImpl();
+          return day.date.toLocaleString(locales, {
+            weekday: "long",
+            month: "long",
+            day: "numeric",
+            year: "numeric",
+            ...options2
+          });
+        }
+      }
+    },
+    getState() {
+      return store.state;
+    },
+    setState: setStateImpl,
+    nextMonth: nextMonthImpl,
+    previousMonth: previousMonthImpl,
+    goToMonth(year, month) {
+      setStateImpl(() => ({
+        referenceDate: Temporal6.PlainDate.from({ year, month, day: 1 })
+      }));
+    },
+    nextWeek: nextWeekImpl,
+    previousWeek: previousWeekImpl,
+    nextDay: nextDayImpl,
+    previousDay: previousDayImpl,
+    goToToday() {
+      setStateImpl(() => ({
+        referenceDate: Temporal6.Now.plainDateISO()
+      }));
+    },
+    goToDate(date) {
+      setStateImpl(() => ({
+        referenceDate: date
+      }));
+    },
+    next(view) {
+      switch (view) {
+        case "month":
+          nextMonthImpl();
+          break;
+        case "week":
+          nextWeekImpl();
+          break;
+        case "day":
+          nextDayImpl();
+          break;
+      }
+    },
+    previous(view) {
+      switch (view) {
+        case "month":
+          previousMonthImpl();
+          break;
+        case "week":
+          previousWeekImpl();
+          break;
+        case "day":
+          previousDayImpl();
+          break;
+      }
+    },
+    get views() {
+      return configuredViews;
+    },
+    get currentView() {
+      return store.state.currentView || defaultView;
+    },
+    setCurrentView(view) {
+      setStateImpl((old) => ({
+        ...old,
+        currentView: view
+      }));
+    },
+    get dateRange() {
+      return store.state.dateRange;
+    },
+    get options() {
+      return _options;
+    },
+    setOptions(updater) {
+      _options = functionalUpdate(updater, _options);
+    },
+    store
+  };
+  return calendar;
+}
+
+// src/createCalendarViews.ts
+function createCalendarViews() {
+  return (views) => {
+    return views;
+  };
+}
+export {
+  buildDay,
+  buildMonth,
+  buildWeek,
+  convertToTimezone,
+  createCalendar,
+  createCalendarAccessor,
+  createCalendarViews,
+  createZonedDateTime,
+  formatTime,
+  functionalUpdate,
+  getCurrentTimeZone,
+  getDayDateRange,
+  getDayRange,
+  getEventPosition,
+  getMonthDateRange,
+  getMonthName,
+  getMonthRange,
+  getTimeSlotHeight,
+  getTimezoneOffset,
+  getWeekDateRange,
+  getWeekRange,
+  getWeekdays,
+  goToToday,
+  nextDay,
+  nextMonth,
+  nextWeek,
+  previousDay,
+  previousMonth,
+  previousWeek
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@gobrand/calendar-core",
+  "version": "0.0.3",
+  "description": "Lightweight utility library for building calendars using the Temporal API",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/go-brand/calendar.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/go-brand/calendar/issues"
+  },
+  "homepage": "https://github.com/go-brand/calendar#readme",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@js-temporal/polyfill": "^0.5.1",
+    "@tanstack/store": "^0.8.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.17",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "keywords": [
+    "temporal",
+    "calendar",
+    "date",
+    "datetime",
+    "time",
+    "temporal-api",
+    "month",
+    "week",
+    "year"
+  ]
+}