@lazerlen/legend-calendar 1.0.0

package/src/helpers/dates.ts

@@ -0,0 +1,163 @@
+/**
+ * Returns the date formatted as YYYY-MM-DD, ensuring timezone doesn't affect
+ * the result.
+ */
+export function toDateId(date: Date) {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1; // getMonth() returns 0-11
+  const day = date.getDate();
+
+  // Pad single digit month and day with leading zeros
+  const monthFormatted = month < 10 ? `0${month}` : month;
+  const dayFormatted = day < 10 ? `0${day}` : day;
+
+  return `${year}-${monthFormatted}-${dayFormatted}`;
+}
+
+/**
+ * Converts a date ID to a `Date` object, correctly accounting for timezone.
+ */
+export function fromDateId(dateId: string) {
+  const [year, month, day] = dateId.split("-").map(Number);
+  return new Date(year, month - 1, day);
+}
+
+/**
+ * Returns the first day of the month for the given date.
+ */
+export function startOfMonth(date: Date) {
+  return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+
+/**
+ * Returns the last day of the month for the given date.
+ */
+export function endOfMonth(date: Date) {
+  const nextMonth = new Date(date.getFullYear(), date.getMonth() + 1, 1);
+  const lastDay = new Date(nextMonth.getTime() - 1);
+  return new Date(lastDay);
+}
+
+/**
+ * Returns the first day of the week for the given date.
+ */
+export function startOfWeek(
+  baseDate: Date,
+  firstDayOfWeek: "monday" | "sunday"
+): Date {
+  // Clone the baseDate to avoid modifying the original date
+  const date = new Date(baseDate.getTime());
+
+  // Calculate the day of the week (0 for Sunday, 1 for Monday, etc.)
+  const dayOfWeek = date.getDay();
+  const isSunday = dayOfWeek === 0;
+
+  if (isSunday && firstDayOfWeek === "monday") {
+    date.setDate(date.getDate() - 6);
+    return date;
+  }
+
+  // Calculate the difference between the current day and the first day of the week
+  const diff = dayOfWeek - (firstDayOfWeek === "monday" ? 1 : 0);
+  date.setDate(date.getDate() - diff);
+
+  return date;
+}
+
+/**
+ * Add `n` months to the given date.
+ */
+export function addMonths(date: Date, months: number) {
+  const newDate = new Date(date);
+  newDate.setMonth(newDate.getMonth() + months);
+  return newDate;
+}
+
+/**
+ * Subtract `n` months from the given date.
+ */
+export function subMonths(date: Date, months: number) {
+  const newDate = new Date(date);
+  newDate.setMonth(newDate.getMonth() - months);
+  return newDate;
+}
+
+/**
+ * Add `n` days to the given date.
+ */
+export function addDays(date: Date, days: number) {
+  const newDate = new Date(date);
+  newDate.setDate(newDate.getDate() + days);
+  return newDate;
+}
+
+/**
+ * Subtract `n` days from the given date.
+ */
+export function subDays(date: Date, days: number) {
+  const newDate = new Date(date);
+  newDate.setDate(newDate.getDate() - days);
+  return newDate;
+}
+
+/**
+ * Does the given date fall on a weekend?
+ */
+export function isWeekend(date: Date) {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
+
+/**
+ * Get the number of months between the given dates.
+ */
+export function differenceInMonths(laterDate: Date, earlierDate: Date) {
+  const yearDiff = laterDate.getFullYear() - earlierDate.getFullYear();
+  const monthDiff = laterDate.getMonth() - earlierDate.getMonth();
+
+  return yearDiff * 12 + monthDiff;
+}
+
+/**
+ * Get the number of weeks in the month for the given date.
+ */
+export function getWeeksInMonth(
+  date: Date,
+  firstDayOfWeek: "monday" | "sunday"
+) {
+  const firstDay = new Date(date.getFullYear(), date.getMonth(), 1);
+  let dayOfWeek = firstDay.getDay();
+
+  // Adjust the first day of the week
+  if (firstDayOfWeek === "monday") {
+    dayOfWeek = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+  }
+
+  const totalDays = new Date(
+    date.getFullYear(),
+    date.getMonth() + 1,
+    0
+  ).getDate();
+
+  return Math.ceil((dayOfWeek + totalDays) / 7);
+}
+
+/**
+ * Get the week of the month of the given date. The week index is 1-based.
+ */
+export function getWeekOfMonth(
+  date: Date,
+  firstDayOfWeek: "monday" | "sunday"
+) {
+  const firstDay = new Date(date.getFullYear(), date.getMonth(), 1);
+  let dayOfWeek = firstDay.getDay();
+
+  // Adjust the first day of the week
+  if (firstDayOfWeek === "monday") {
+    dayOfWeek = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+  }
+
+  const dayOfMonth = date.getDate();
+
+  return Math.floor((dayOfWeek + dayOfMonth - 1) / 7) + 1;
+}

package/src/helpers/functions.ts

@@ -0,0 +1,327 @@
+/**
+ * Pipes the value of an expression into a pipeline of functions.
+ *
+ * See also [`flow`](#flow).
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ *
+ * const len = (s: string): number => s.length
+ * const double = (n: number): number => n * 2
+ *
+ * // without pipe
+ * assert.strictEqual(double(len('aaa')), 6)
+ *
+ * // with pipe
+ * assert.strictEqual(pipe('aaa', len, double), 6)
+ *
+ * @remark copied from https://github.com/gcanti/fp-ts/blob/master/src/function.ts
+ */
+export function pipe<A>(a: A): A;
+export function pipe<A, B>(a: A, ab: (a: A) => B): B;
+export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+export function pipe<A, B, C, D>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D
+): D;
+export function pipe<A, B, C, D, E>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E
+): E;
+export function pipe<A, B, C, D, E, F>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F
+): F;
+export function pipe<A, B, C, D, E, F, G>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G
+): G;
+export function pipe<A, B, C, D, E, F, G, H>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H
+): H;
+export function pipe<A, B, C, D, E, F, G, H, I>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I
+): I;
+export function pipe<A, B, C, D, E, F, G, H, I, J>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J
+): J;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K
+): K;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L
+): L;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M
+): M;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N
+): N;
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O
+): O;
+
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P
+): P;
+
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q
+): Q;
+
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R
+): R;
+
+export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R,
+  rs: (r: R) => S
+): S;
+
+export function pipe<
+  A,
+  B,
+  C,
+  D,
+  E,
+  F,
+  G,
+  H,
+  I,
+  J,
+  K,
+  L,
+  M,
+  N,
+  O,
+  P,
+  Q,
+  R,
+  S,
+  T
+>(
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+  cd: (c: C) => D,
+  de: (d: D) => E,
+  ef: (e: E) => F,
+  fg: (f: F) => G,
+  gh: (g: G) => H,
+  hi: (h: H) => I,
+  ij: (i: I) => J,
+  jk: (j: J) => K,
+  kl: (k: K) => L,
+  lm: (l: L) => M,
+  mn: (m: M) => N,
+  no: (n: N) => O,
+  op: (o: O) => P,
+  pq: (p: P) => Q,
+  qr: (q: Q) => R,
+  rs: (r: R) => S,
+  st: (s: S) => T
+): T;
+export function pipe(
+  a: unknown,
+  ab?: Function,
+  bc?: Function,
+  cd?: Function,
+  de?: Function,
+  ef?: Function,
+  fg?: Function,
+  gh?: Function,
+  hi?: Function
+): unknown {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab!(a);
+    case 3:
+      return bc!(ab!(a));
+    case 4:
+      return cd!(bc!(ab!(a)));
+    case 5:
+      return de!(cd!(bc!(ab!(a))));
+    case 6:
+      return ef!(de!(cd!(bc!(ab!(a)))));
+    case 7:
+      return fg!(ef!(de!(cd!(bc!(ab!(a))))));
+    case 8:
+      return gh!(fg!(ef!(de!(cd!(bc!(ab!(a)))))));
+    case 9:
+      return hi!(gh!(fg!(ef!(de!(cd!(bc!(ab!(a))))))));
+    default: {
+      // eslint-disable-next-line prefer-rest-params
+      let ret = arguments[0];
+      for (let i = 1; i < arguments.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, prefer-rest-params
+        ret = arguments[i](ret);
+      }
+      return ret;
+    }
+  }
+}

package/src/helpers/numbers.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a list of numbers from `start` (inclusive) to `stop`
+ * (inclusive). In mathematical terms, `range(a, b)` is equivalent to
+ * the interval `[a, b]`.
+ *
+ * An optional `step` can be provided to control the size of the increemnt (defaults to `1`).
+ *
+ * Copied from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from
+ */
+export const range = (start: number, stop: number, step = 1) =>
+  Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step);

package/src/helpers/strings.ts

@@ -0,0 +1,2 @@
+export const uppercaseFirstLetter = (value: string) =>
+  value.charAt(0).toUpperCase() + value.slice(1);

package/src/helpers/tokens.ts

@@ -0,0 +1,71 @@
+const baseTokens = {
+  spacing: {
+    0: 0,
+    2: 2,
+    4: 4,
+    6: 6,
+    8: 8,
+    12: 12,
+    16: 16,
+    20: 20,
+    24: 24,
+  },
+} as const;
+
+/**
+ * Minimal theme for the Legend Calendar component.
+ * @internal
+ */
+export const lightTheme = {
+  ...baseTokens,
+  colors: {
+    content: {
+      disabled: "#B0B0B0",
+      primary: "#000000",
+      secondary: "#212121",
+      inverse: {
+        primary: "#FFFFFF",
+      },
+    },
+    background: {
+      primary: "#FFFFFF",
+      tertiary: "#EDEFEE",
+      tertiaryPressed: "#D1D2D3",
+      inverse: {
+        primary: "#000000",
+      },
+    },
+    borders: {
+      default: "#E0E0E0",
+    },
+    transparent: "transparent",
+  },
+} as const;
+
+export const darkTheme = {
+  ...baseTokens,
+  colors: {
+    content: {
+      disabled: "#bdbdbd",
+      primary: "#FFFFFF",
+      secondary: "#e8e8e8",
+      inverse: {
+        primary: "#000000",
+      },
+    },
+    background: {
+      primary: "#000000",
+      tertiary: "#111111",
+      tertiaryPressed: "#212121",
+      inverse: {
+        primary: "#FFFFFF",
+      },
+    },
+    borders: {
+      default: "#5c5c5c",
+    },
+    transparent: "transparent",
+  },
+} as const;
+
+export type BaseTheme = typeof lightTheme | typeof darkTheme;

package/src/helpers/types.ts

@@ -0,0 +1,3 @@
+export function exhaustiveCheck(_x: never): never {
+  throw new Error("Didn't expect to get here");
+}