v-calendar-3 1.0.0

package/src/utils/date/range.ts

@@ -0,0 +1,274 @@
+import { isArray, isDate, isObject } from '../helpers';
+import Locale from '../locale';
+import type { CalendarDay } from '../page';
+import { type DateParts, type DayParts, MS_PER_DAY, addDays } from './helpers';
+import { DateRepeat, type DateRepeatConfig } from './repeat';
+
+type DateRangeDate = Date | string | number | null;
+
+interface DateRangeConfig {
+  start: DateRangeDate;
+  end: DateRangeDate;
+  span: number;
+  order: number;
+  repeat: Partial<DateRepeatConfig>;
+}
+
+export type DateRangeSource =
+  | DateRange
+  | DateRangeDate
+  | [DateRangeDate, DateRangeDate]
+  | Partial<DateRangeConfig>;
+
+export interface SimpleDateRange {
+  start: Date;
+  end: Date;
+}
+
+export class DateRange {
+  order: number;
+  locale: Locale;
+  start: DateParts | null = null;
+  end: DateParts | null = null;
+  repeat: DateRepeat | null = null;
+
+  static fromMany(ranges: DateRangeSource | DateRangeSource[], locale: Locale) {
+    // Assign dates
+    return (isArray(ranges) ? ranges : [ranges])
+      .filter(d => d)
+      .map(d => DateRange.from(d, locale));
+  }
+
+  static from(source: DateRangeSource, locale: Locale) {
+    if (source instanceof DateRange) return source;
+    const config: Partial<DateRangeConfig> = {
+      start: null,
+      end: null,
+    };
+    if (source != null) {
+      if (isArray(source)) {
+        config.start = source[0] ?? null;
+        config.end = source[1] ?? null;
+      } else if (isObject(source)) {
+        Object.assign(config, source);
+      } else {
+        config.start = source;
+        config.end = source;
+      }
+    }
+    if (config.start != null) {
+      config.start = locale.toDateOrNull(config.start);
+    }
+    if (config.end != null) {
+      config.end = locale.toDateOrNull(config.end);
+    }
+    return new DateRange(config, locale);
+  }
+
+  private constructor(config: Partial<DateRangeConfig>, locale = new Locale()) {
+    this.locale = locale;
+    const { start, end, span, order, repeat } = config;
+
+    if (isDate(start)) {
+      this.start = locale.getDateParts(start);
+    }
+
+    if (isDate(end)) {
+      this.end = locale.getDateParts(end);
+    } else if (this.start != null && span) {
+      this.end = locale.getDateParts(addDays(this.start.date, span - 1));
+    }
+
+    this.order = order ?? 0;
+
+    if (repeat) {
+      this.repeat = new DateRepeat(
+        {
+          from: this.start?.date,
+          ...repeat,
+        },
+        {
+          locale: this.locale,
+        },
+      );
+    }
+  }
+
+  get opts() {
+    const { order, locale } = this;
+    return { order, locale };
+  }
+
+  get hasRepeat() {
+    return !!this.repeat;
+  }
+
+  get isSingleDay() {
+    const { start, end } = this;
+    return (
+      start &&
+      end &&
+      start.year === end.year &&
+      start.month === end.month &&
+      start.day === end.day
+    );
+  }
+
+  get isMultiDay() {
+    return !this.isSingleDay;
+  }
+
+  get daySpan() {
+    if (this.start == null || this.end == null) {
+      if (this.hasRepeat) return 1;
+      return Infinity;
+    }
+    return this.end.dayIndex - this.start.dayIndex;
+  }
+
+  startsOnDay(dayParts: DayParts) {
+    return (
+      this.start?.dayIndex === dayParts.dayIndex ||
+      !!this.repeat?.passes(dayParts)
+    );
+  }
+
+  intersectsDay(dayIndex: number) {
+    return this.intersectsDayRange(dayIndex, dayIndex);
+  }
+
+  intersectsRange(range: DateRange) {
+    return this.intersectsDayRange(
+      range.start?.dayIndex ?? -Infinity,
+      range.end?.dayIndex ?? Infinity,
+    );
+  }
+
+  intersectsDayRange(startDayIndex: number, endDayIndex: number) {
+    if (this.start && this.start.dayIndex > endDayIndex) return false;
+    if (this.end && this.end.dayIndex < startDayIndex) return false;
+    return true;
+  }
+}
+
+interface DataRange {
+  startDay: number;
+  startTime: number;
+  endDay: number;
+  endTime: number;
+}
+
+export interface RangeData {
+  key: string | number;
+  order?: number;
+}
+
+interface DataRanges {
+  ranges: DataRange[];
+  data: RangeData;
+}
+
+export interface DateRangeCell<T extends RangeData> extends DataRange {
+  data: T;
+  onStart: boolean;
+  onEnd: boolean;
+  startTime: number;
+  startDate: Date;
+  endTime: number;
+  endDate: Date;
+  allDay: boolean;
+  order: number;
+}
+
+export class DateRangeContext {
+  private records: Record<string, DataRanges> = {};
+
+  render(data: RangeData, range: DateRange, days: DayParts[]) {
+    let result = null;
+    const startDayIndex = days[0]?.dayIndex ?? 0;
+    const endDayIndex = days[days.length - 1]?.dayIndex ?? 0;
+    if (range.hasRepeat) {
+      days.forEach(day => {
+        if (range.startsOnDay(day)) {
+          const span = range.daySpan < Infinity ? range.daySpan : 1;
+          result = {
+            startDay: day.dayIndex,
+            startTime: range.start?.time ?? 0,
+            endDay: day.dayIndex + span - 1,
+            endTime: range.end?.time ?? MS_PER_DAY,
+          };
+          this.getRangeRecords(data).push(result);
+        }
+      });
+    } else if (range.intersectsDayRange(startDayIndex, endDayIndex)) {
+      result = {
+        startDay: range.start?.dayIndex ?? -Infinity,
+        startTime: range.start?.time ?? -Infinity,
+        endDay: range.end?.dayIndex ?? Infinity,
+        endTime: range.end?.time ?? Infinity,
+      };
+      this.getRangeRecords(data).push(result);
+    }
+    return result;
+  }
+
+  private getRangeRecords(data: RangeData) {
+    let record = this.records[data.key];
+    if (!record) {
+      record = {
+        ranges: [],
+        data,
+      };
+      this.records[data.key] = record;
+    }
+    return record.ranges;
+  }
+
+  getCell(key: string | number, day: CalendarDay) {
+    const cells = this.getCells(day);
+    const result = cells.find(cell => cell.data.key === key);
+    return result;
+  }
+
+  cellExists(key: string | number, dayIndex: number) {
+    const records = this.records[key];
+    if (records == null) return false;
+    return records.ranges.some(
+      r => r.startDay <= dayIndex && r.endDay >= dayIndex,
+    );
+  }
+
+  getCells(day: CalendarDay) {
+    const records = Object.values(this.records);
+    const result: DateRangeCell<any>[] = [];
+    const { dayIndex } = day;
+    records.forEach(({ data, ranges }) => {
+      ranges
+        .filter(r => r.startDay <= dayIndex && r.endDay >= dayIndex)
+        .forEach(range => {
+          const onStart = dayIndex === range.startDay;
+          const onEnd = dayIndex === range.endDay;
+          const startTime = onStart ? range.startTime : 0;
+          const startDate = new Date(day.startDate.getTime() + startTime);
+          const endTime = onEnd ? range.endTime : MS_PER_DAY;
+          const endDate = new Date(day.endDate.getTime() + endTime);
+          const allDay = startTime === 0 && endTime === MS_PER_DAY;
+          const order = data.order || 0;
+          result.push({
+            ...range,
+            data,
+            onStart,
+            onEnd,
+            startTime,
+            startDate,
+            endTime,
+            endDate,
+            allDay,
+            order,
+          });
+        });
+    });
+    result.sort((a, b) => a.order - b.order);
+    return result;
+  }
+}

package/src/utils/date/repeat.ts

@@ -0,0 +1,135 @@
+import { isArray, isFunction, isObject, isString } from '../helpers';
+import Locale from '../locale';
+import type {
+  DateParts,
+  DayInMonth,
+  DayOfWeek,
+  DayParts,
+  MonthInYear,
+  WeekInMonth,
+} from './helpers';
+import {
+  ComponentRule,
+  ComponentRuleType,
+  FunctionRule,
+  GroupRuleType,
+  IntervalRule,
+  IntervalRuleType,
+  OrdinalComponentRule,
+  OrdinalComponentRuleType,
+  type Rule,
+  type RuleType,
+  type SingleOrArray,
+} from './rules';
+
+export type RepeatIntervalShort = 'day' | 'week' | 'month' | 'year';
+
+export type RepeatInterval = 'days' | 'weeks' | 'months' | 'years';
+export interface DateRepeatConfig {
+  every: RepeatIntervalShort | [number, RepeatInterval];
+  from: Date;
+  until: Date;
+  weekdays: SingleOrArray<DayOfWeek>;
+  days: SingleOrArray<DayInMonth>;
+  weeks: SingleOrArray<WeekInMonth>;
+  months: SingleOrArray<MonthInYear>;
+  years: SingleOrArray<number>;
+  ordinalWeekdays: SingleOrArray<number[]>;
+  on: SingleOrArray<DateRepeatFn | Partial<DateRepeatConfig>>;
+}
+
+export type DateRepeatFn = (dayParts: DayParts) => boolean;
+
+export interface DateRepeatOptions {
+  locale: Locale;
+}
+
+export class DateRepeat implements Rule<GroupRuleType> {
+  validated = true;
+
+  config: Partial<DateRepeatConfig> | DateRepeatFn;
+  type = GroupRuleType.Any;
+  from: DateParts | undefined;
+  until: DateParts | undefined;
+  rules: Rule<RuleType>[] = [];
+  locale = new Locale();
+
+  constructor(
+    config: Partial<DateRepeatConfig> | DateRepeatFn,
+    options: Partial<DateRepeatOptions> = {},
+    private parent?: DateRepeat,
+  ) {
+    if (options.locale) this.locale = options.locale;
+
+    this.config = config;
+    if (isFunction(config)) {
+      this.type = GroupRuleType.All;
+      this.rules = [new FunctionRule(config)];
+    } else if (isArray(config)) {
+      this.type = GroupRuleType.Any;
+      this.rules = config.map(c => new DateRepeat(c, options, this));
+    } else if (isObject(config)) {
+      this.type = GroupRuleType.All;
+      // Assign bounding dates
+      this.from = config.from
+        ? this.locale.getDateParts(config.from)
+        : parent?.from;
+      this.until = config.until
+        ? this.locale.getDateParts(config.until)
+        : parent?.until;
+      this.rules = this.getObjectRules(config);
+    } else {
+      console.error('Rule group configuration must be an object or an array.');
+      this.validated = false;
+    }
+  }
+
+  getObjectRules(config: any) {
+    const rules: Rule<RuleType>[] = [];
+
+    // Add interval rule
+    if (config.every) {
+      if (isString(config.every)) {
+        config.every = [1, `${config.every}s`];
+      }
+      if (isArray(config.every)) {
+        const [interval = 1, type = IntervalRuleType.Days] = config.every;
+        rules.push(new IntervalRule(type, interval, this.from!));
+      }
+    }
+
+    // Add component rules
+    Object.values(ComponentRuleType).forEach(type => {
+      if (!(type in config)) return;
+      rules.push(ComponentRule.create(type, config[type]));
+    });
+
+    // Add ordinal component rules
+    Object.values(OrdinalComponentRuleType).forEach(type => {
+      if (!(type in config)) return;
+      rules.push(new OrdinalComponentRule(type, config[type]));
+    });
+
+    // Add group rules
+    if (config.on != null) {
+      if (!isArray(config.on)) config.on = [config.on];
+      rules.push(
+        new DateRepeat(config.on, { locale: this.locale }, this.parent),
+      );
+    }
+
+    return rules;
+  }
+
+  passes(dayParts: DayParts) {
+    if (!this.validated) return true;
+
+    if (this.from && dayParts.dayIndex <= this.from.dayIndex) return false;
+    if (this.until && dayParts.dayIndex >= this.until.dayIndex) return false;
+
+    if (this.type === GroupRuleType.Any) {
+      return this.rules.some(r => r.passes(dayParts));
+    }
+    return this.rules.every(r => r.passes(dayParts));
+  }
+}

package/src/utils/date/rules.ts

@@ -0,0 +1,290 @@
+import { isArray, isFunction, isNumber } from '../helpers';
+import {
+  type DayOfWeek,
+  type DayParts,
+  type OrdinalWeekInMonth,
+  diffInDays,
+  diffInMonths,
+  diffInWeeks,
+  diffInYears,
+  isDayInMonth,
+  isDayOfWeek,
+  isMonthInYear,
+  isOrdinalWeekInMonth,
+  isWeekInMonth,
+} from './helpers';
+
+export type SingleOrArray<T> = T | T[];
+
+export enum GroupRuleType {
+  Any = 'any',
+  All = 'all',
+}
+
+export enum IntervalRuleType {
+  Days = 'days',
+  Weeks = 'weeks',
+  Months = 'months',
+  Years = 'years',
+}
+
+export enum ComponentRuleType {
+  Days = 'days',
+  Weekdays = 'weekdays',
+  Weeks = 'weeks',
+  Months = 'months',
+  Years = 'years',
+}
+
+export enum OrdinalComponentRuleType {
+  OrdinalWeekdays = 'ordinalWeekdays',
+}
+
+export enum FunctionRuleType {
+  Function = 'function',
+}
+
+export type RuleType =
+  | GroupRuleType
+  | IntervalRuleType
+  | ComponentRuleType
+  | OrdinalComponentRuleType
+  | FunctionRuleType;
+
+export type OrdinalArrayConfig = SingleOrArray<
+  [OrdinalWeekInMonth, ...DayOfWeek[]]
+>;
+
+export interface Rule<T> {
+  type: T;
+  passes(dayParts: DayParts): boolean;
+}
+
+export class IntervalRule implements Rule<IntervalRuleType> {
+  private validated = true;
+
+  constructor(
+    public type: IntervalRuleType,
+    public interval: number,
+    public from: DayParts,
+  ) {
+    // Start date needed for interval rules
+    if (!this.from) {
+      console.error(
+        `A valid "from" date is required for date interval rule. This rule will be skipped.`,
+      );
+      this.validated = false;
+    }
+  }
+
+  passes(dateParts: DayParts) {
+    if (!this.validated) return true;
+
+    const { date } = dateParts;
+    switch (this.type) {
+      case 'days': {
+        return diffInDays(this.from.date, date) % this.interval === 0;
+      }
+      case 'weeks': {
+        return diffInWeeks(this.from.date, date) % this.interval === 0;
+      }
+      case 'months': {
+        return diffInMonths(this.from.date, date) % this.interval === 0;
+      }
+      case 'years': {
+        return diffInYears(this.from.date, date) % this.interval === 0;
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+}
+
+export class ComponentRule implements Rule<ComponentRuleType> {
+  components: number[] = [];
+
+  static create(type: ComponentRuleType, config: unknown) {
+    switch (type) {
+      case ComponentRuleType.Days:
+        return new DaysRule(config);
+      case ComponentRuleType.Weekdays:
+        return new WeekdaysRule(config);
+      case ComponentRuleType.Weeks:
+        return new WeeksRule(config);
+      case ComponentRuleType.Months:
+        return new MonthsRule(config);
+      case ComponentRuleType.Years:
+        return new YearsRule(config);
+    }
+  }
+
+  constructor(
+    public type: ComponentRuleType,
+    components: unknown,
+    public validator: (component: unknown) => component is number,
+    public getter: (dayParts: DayParts) => number[],
+  ) {
+    this.components = this.normalizeComponents(components);
+  }
+
+  normalizeComponents(components: unknown) {
+    if (this.validator(components)) return [components];
+    if (!isArray(components)) return [];
+    const result: number[] = [];
+    components.forEach(component => {
+      if (!this.validator(component)) {
+        console.error(
+          `Component value ${component} in invalid for "${this.type}" rule. This rule will be skipped.`,
+        );
+        return;
+      }
+      result.push(component);
+    });
+    return result;
+  }
+
+  passes(dayParts: DayParts) {
+    const comps = this.getter(dayParts);
+    const result = comps.some(comp => this.components.includes(comp));
+    return result;
+  }
+}
+
+export class DaysRule extends ComponentRule {
+  constructor(components: unknown) {
+    super(
+      ComponentRuleType.Days,
+      components,
+      isDayInMonth,
+      ({ day, dayFromEnd }) => [day, -dayFromEnd],
+    );
+  }
+}
+
+export class WeekdaysRule extends ComponentRule {
+  constructor(components: unknown) {
+    super(
+      ComponentRuleType.Weekdays,
+      components,
+      isDayOfWeek,
+      ({ weekday }) => [weekday],
+    );
+  }
+}
+
+export class WeeksRule extends ComponentRule {
+  constructor(components: unknown) {
+    super(
+      ComponentRuleType.Weeks,
+      components,
+      isWeekInMonth,
+      ({ week, weekFromEnd }) => [week, -weekFromEnd],
+    );
+  }
+}
+
+export class MonthsRule extends ComponentRule {
+  constructor(components: unknown) {
+    super(ComponentRuleType.Months, components, isMonthInYear, ({ month }) => [
+      month,
+    ]);
+  }
+}
+
+export class YearsRule extends ComponentRule {
+  constructor(components: unknown) {
+    super(ComponentRuleType.Years, components, isNumber, ({ year }) => [year]);
+  }
+}
+
+export class OrdinalComponentRule implements Rule<OrdinalComponentRuleType> {
+  components: [OrdinalWeekInMonth, DayOfWeek][];
+
+  constructor(
+    public type: OrdinalComponentRuleType,
+    components: OrdinalArrayConfig,
+  ) {
+    this.components = this.normalizeComponents(components);
+  }
+
+  normalizeArrayConfig(config: OrdinalArrayConfig) {
+    const result: [OrdinalWeekInMonth, DayOfWeek][] = [];
+    config.forEach((numOrArray, i) => {
+      if (isNumber(numOrArray)) {
+        if (i === 0) return;
+        if (!isOrdinalWeekInMonth(config[0])) {
+          console.error(
+            `Ordinal range for "${this.type}" rule is from -5 to -1 or 1 to 5. This rule will be skipped.`,
+          );
+          return;
+        }
+        if (!isDayOfWeek(numOrArray)) {
+          console.error(
+            `Acceptable range for "${this.type}" rule is from 1 to 5. This rule will be skipped`,
+          );
+          return;
+        }
+        result.push([config[0], numOrArray]);
+      } else if (isArray(numOrArray)) {
+        result.push(...this.normalizeArrayConfig(numOrArray));
+      }
+    });
+    return result;
+  }
+
+  normalizeComponents(config: OrdinalArrayConfig) {
+    const result: [OrdinalWeekInMonth, DayOfWeek][] = [];
+    config.forEach((numOrArray, i) => {
+      if (isNumber(numOrArray)) {
+        if (i === 0) return;
+        if (!isOrdinalWeekInMonth(config[0])) {
+          console.error(
+            `Ordinal range for "${this.type}" rule is from -5 to -1 or 1 to 5. This rule will be skipped.`,
+          );
+          return;
+        }
+        if (!isDayOfWeek(numOrArray)) {
+          console.error(
+            `Acceptable range for "${this.type}" rule is from 1 to 5. This rule will be skipped`,
+          );
+          return;
+        }
+        result.push([config[0], numOrArray]);
+      } else if (isArray(numOrArray)) {
+        result.push(...this.normalizeArrayConfig(numOrArray));
+      }
+    });
+    return result;
+  }
+
+  passes(dayParts: DayParts) {
+    const { weekday, weekdayOrdinal, weekdayOrdinalFromEnd } = dayParts;
+    return this.components.some(
+      ([ordinalWeek, ordinalWeekday]) =>
+        (ordinalWeek === weekdayOrdinal ||
+          ordinalWeek === -weekdayOrdinalFromEnd) &&
+        weekday === ordinalWeekday,
+    );
+  }
+}
+
+export class FunctionRule implements Rule<FunctionRuleType> {
+  type = FunctionRuleType.Function;
+  private validated = true;
+
+  constructor(public fn: Function) {
+    if (!isFunction(fn)) {
+      console.error(
+        `The function rule requires a valid function. This rule will be skipped.`,
+      );
+      this.validated = false;
+    }
+  }
+
+  passes(dayParts: DayParts) {
+    if (!this.validated) return true;
+
+    return this.fn(dayParts);
+  }
+}