Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 553 insertions, 0 deletions

diff --git a/comm/calendar/base/modules/calRecurrenceUtils.jsm b/comm/calendar/base/modules/calRecurrenceUtils.jsm
new file mode 100644
index 0000000000..125f429801
--- /dev/null
+++ b/comm/calendar/base/modules/calRecurrenceUtils.jsm
@@ -0,0 +1,553 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* exported recurrenceStringFromItem, recurrenceRule2String, splitRecurrenceRules,
+ *          checkRecurrenceRule, countOccurrences
+ */
+
+var { PluralForm } = ChromeUtils.importESModule("resource://gre/modules/PluralForm.sys.mjs");
+var { XPCOMUtils } = ChromeUtils.importESModule("resource://gre/modules/XPCOMUtils.sys.mjs");
+var { cal } = ChromeUtils.import("resource:///modules/calendar/calUtils.jsm");
+
+const lazy = {};
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  CalRecurrenceDate: "resource:///modules/CalRecurrenceDate.jsm",
+  CalRecurrenceRule: "resource:///modules/CalRecurrenceRule.jsm",
+});
+
+const EXPORTED_SYMBOLS = [
+  "recurrenceStringFromItem",
+  "recurrenceRule2String",
+  "splitRecurrenceRules",
+  "checkRecurrenceRule",
+  "countOccurrences",
+  "hasUnsupported",
+];
+
+/**
+ * Given a calendar event or task, return a string that describes the item's
+ * recurrence pattern. When the recurrence pattern is too complex, return a
+ * "too complex" string by getting that string using the arguments provided.
+ *
+ * @param {calIEvent | calITodo} item   A calendar item.
+ * @param {string} bundleName - Name of the properties file, e.g. "calendar-event-dialog".
+ * @param {string} stringName - Name of the string within the properties file.
+ * @param {string[]} [params] - (optional) Parameters to format the string.
+ * @returns {string | null} A string describing the recurrence
+ *                                        pattern or null if the item has no
+ *                                        recurrence info.
+ */
+function recurrenceStringFromItem(item, bundleName, stringName, params) {
+  // See the `parentItem` property of `calIItemBase`.
+  let parent = item.parentItem;
+
+  let recurrenceInfo = parent.recurrenceInfo;
+  if (!recurrenceInfo) {
+    return null;
+  }
+
+  let kDefaultTimezone = cal.dtz.defaultTimezone;
+
+  let rawStartDate = parent.startDate || parent.entryDate;
+  let rawEndDate = parent.endDate || parent.dueDate;
+
+  let startDate = rawStartDate ? rawStartDate.getInTimezone(kDefaultTimezone) : null;
+  let endDate = rawEndDate ? rawEndDate.getInTimezone(kDefaultTimezone) : null;
+
+  return (
+    recurrenceRule2String(recurrenceInfo, startDate, endDate, startDate.isDate) ||
+    cal.l10n.getString(bundleName, stringName, params)
+  );
+}
+
+/**
+ * This function takes the recurrence info passed as argument and creates a
+ * literal string representing the repeat pattern in natural language.
+ *
+ * @param recurrenceInfo    An item's recurrence info to parse.
+ * @param startDate         The start date to base rules on.
+ * @param endDate           The end date to base rules on.
+ * @param allDay            If true, the pattern should assume an allday item.
+ * @returns A human readable string describing the recurrence.
+ */
+function recurrenceRule2String(recurrenceInfo, startDate, endDate, allDay) {
+  function getRString(name, args) {
+    return cal.l10n.getString("calendar-event-dialog", name, args);
+  }
+  function day_of_week(day) {
+    return Math.abs(day) % 8;
+  }
+  function day_position(day) {
+    return ((Math.abs(day) - day_of_week(day)) / 8) * (day < 0 ? -1 : 1);
+  }
+  function nounClass(aDayString, aRuleString) {
+    // Select noun class (grammatical gender) for rule string
+    let nounClassStr = getRString(aDayString + "Nounclass");
+    return aRuleString + nounClassStr.substr(0, 1).toUpperCase() + nounClassStr.substr(1);
+  }
+  function pluralWeekday(aDayString) {
+    let plural = getRString("pluralForWeekdays") == "true";
+    return plural ? aDayString + "Plural" : aDayString;
+  }
+  function everyWeekDay(aByDay) {
+    // Checks if aByDay contains only values from 1 to 7 with any order.
+    let mask = aByDay.reduce((value, item) => value | (1 << item), 1);
+    return aByDay.length == 7 && mask == Math.pow(2, 8) - 1;
+  }
+
+  // Retrieve a valid recurrence rule from the currently
+  // set recurrence info. Bail out if there's more
+  // than a single rule or something other than a rule.
+  recurrenceInfo = recurrenceInfo.clone();
+  if (hasUnsupported(recurrenceInfo)) {
+    return null;
+  }
+
+  let rrules = splitRecurrenceRules(recurrenceInfo);
+  if (rrules[0].length == 1) {
+    let rule = cal.wrapInstance(rrules[0][0], Ci.calIRecurrenceRule);
+    // Currently we allow only for BYDAY, BYMONTHDAY, BYMONTH rules.
+    let byparts = [
+      "BYSECOND",
+      "BYMINUTE",
+      /* "BYDAY", */
+      "BYHOUR",
+      /* "BYMONTHDAY", */
+      "BYYEARDAY",
+      "BYWEEKNO",
+      /* "BYMONTH", */
+      "BYSETPOS",
+    ];
+
+    if (rule && !checkRecurrenceRule(rule, byparts)) {
+      let dateFormatter = cal.dtz.formatter;
+      let ruleString;
+      if (rule.type == "DAILY") {
+        if (checkRecurrenceRule(rule, ["BYDAY"])) {
+          let days = rule.getComponent("BYDAY");
+          let weekdays = [2, 3, 4, 5, 6];
+          if (weekdays.length == days.length) {
+            let i;
+            for (i = 0; i < weekdays.length; i++) {
+              if (weekdays[i] != days[i]) {
+                break;
+              }
+            }
+            if (i == weekdays.length) {
+              ruleString = getRString("repeatDetailsRuleDaily4");
+            }
+          } else {
+            return null;
+          }
+        } else {
+          let dailyString = getRString("dailyEveryNth");
+          ruleString = PluralForm.get(rule.interval, dailyString).replace("#1", rule.interval);
+        }
+      } else if (rule.type == "WEEKLY") {
+        // weekly recurrence, currently we
+        // support a single 'BYDAY'-rule only.
+        if (checkRecurrenceRule(rule, ["BYDAY"])) {
+          // create a string like 'Monday, Tuesday and Wednesday'
+          let days = rule.getComponent("BYDAY");
+          let weekdays = "";
+          // select noun class (grammatical gender) according to the
+          // first day of the list
+          let weeklyString = nounClass("repeatDetailsDay" + days[0], "weeklyNthOn");
+          for (let i = 0; i < days.length; i++) {
+            if (rule.interval == 1) {
+              weekdays += getRString(pluralWeekday("repeatDetailsDay" + days[i]));
+            } else {
+              weekdays += getRString("repeatDetailsDay" + days[i]);
+            }
+            if (days.length > 1 && i == days.length - 2) {
+              weekdays += " " + getRString("repeatDetailsAnd") + " ";
+            } else if (i < days.length - 1) {
+              weekdays += ", ";
+            }
+          }
+
+          weeklyString = getRString(weeklyString, [weekdays]);
+          ruleString = PluralForm.get(rule.interval, weeklyString).replace("#2", rule.interval);
+        } else {
+          let weeklyString = getRString("weeklyEveryNth");
+          ruleString = PluralForm.get(rule.interval, weeklyString).replace("#1", rule.interval);
+        }
+      } else if (rule.type == "MONTHLY") {
+        if (checkRecurrenceRule(rule, ["BYDAY"])) {
+          let byday = rule.getComponent("BYDAY");
+          if (everyWeekDay(byday)) {
+            // Rule every day of the month.
+            ruleString = getRString("monthlyEveryDayOfNth");
+            ruleString = PluralForm.get(rule.interval, ruleString).replace("#2", rule.interval);
+          } else {
+            // For rules with generic number of weekdays with and
+            // without "position" prefix we build two separate
+            // strings depending on the position and then join them.
+            // Notice: we build the description string but currently
+            // the UI can manage only rules with only one weekday.
+            let weekdaysString_every = "";
+            let weekdaysString_position = "";
+            let firstDay = byday[0];
+            for (let i = 0; i < byday.length; i++) {
+              if (day_position(byday[i]) == 0) {
+                if (!weekdaysString_every) {
+                  firstDay = byday[i];
+                }
+                weekdaysString_every +=
+                  getRString(pluralWeekday("repeatDetailsDay" + byday[i])) + ", ";
+              } else {
+                if (day_position(byday[i]) < -1 || day_position(byday[i]) > 5) {
+                  // We support only weekdays with -1 as negative
+                  // position ('THE LAST ...').
+                  return null;
+                }
+
+                let duplicateWeekday = byday.some(element => {
+                  return (
+                    day_position(element) == 0 && day_of_week(byday[i]) == day_of_week(element)
+                  );
+                });
+                if (duplicateWeekday) {
+                  // Prevent to build strings such as for example:
+                  // "every Monday and the second Monday...".
+                  continue;
+                }
+
+                let ordinalString = "repeatOrdinal" + day_position(byday[i]);
+                let dayString = "repeatDetailsDay" + day_of_week(byday[i]);
+                ordinalString = nounClass(dayString, ordinalString);
+                ordinalString = getRString(ordinalString);
+                dayString = getRString(dayString);
+                let stringOrdinalWeekday = getRString("ordinalWeekdayOrder", [
+                  ordinalString,
+                  dayString,
+                ]);
+                weekdaysString_position += stringOrdinalWeekday + ", ";
+              }
+            }
+            let weekdaysString = weekdaysString_every + weekdaysString_position;
+            weekdaysString = weekdaysString
+              .slice(0, -2)
+              .replace(/,(?= [^,]*$)/, " " + getRString("repeatDetailsAnd"));
+
+            let monthlyString = weekdaysString_every
+              ? "monthlyEveryOfEvery"
+              : "monthlyRuleNthOfEvery";
+            monthlyString = nounClass("repeatDetailsDay" + day_of_week(firstDay), monthlyString);
+            monthlyString = getRString(monthlyString, [weekdaysString]);
+            ruleString = PluralForm.get(rule.interval, monthlyString).replace("#2", rule.interval);
+          }
+        } else if (checkRecurrenceRule(rule, ["BYMONTHDAY"])) {
+          let component = rule.getComponent("BYMONTHDAY");
+
+          // First, find out if the 'BYMONTHDAY' component contains
+          // any elements with a negative value lesser than -1 ("the
+          // last day"). If so we currently don't support any rule
+          if (component.some(element => element < -1)) {
+            // we don't support any other combination for now...
+            return getRString("ruleTooComplex");
+          } else if (component.length == 1 && component[0] == -1) {
+            // i.e. one day, the last day of the month
+            let monthlyString = getRString("monthlyLastDayOfNth");
+            ruleString = PluralForm.get(rule.interval, monthlyString).replace("#1", rule.interval);
+          } else {
+            // i.e. one or more monthdays every N months.
+
+            // Build a string with a list of days separated with commas.
+            let day_string = "";
+            let lastDay = false;
+            for (let i = 0; i < component.length; i++) {
+              if (component[i] == -1) {
+                lastDay = true;
+                continue;
+              }
+              day_string += dateFormatter.formatDayWithOrdinal(component[i]) + ", ";
+            }
+            if (lastDay) {
+              day_string += getRString("monthlyLastDay") + ", ";
+            }
+            day_string = day_string
+              .slice(0, -2)
+              .replace(/,(?= [^,]*$)/, " " + getRString("repeatDetailsAnd"));
+
+            // Add the word "day" in plural form to the list of days then
+            // compose the final string with the interval of months
+            let monthlyDayString = getRString("monthlyDaysOfNth_day", [day_string]);
+            monthlyDayString = PluralForm.get(component.length, monthlyDayString);
+            let monthlyString = getRString("monthlyDaysOfNth", [monthlyDayString]);
+            ruleString = PluralForm.get(rule.interval, monthlyString).replace("#2", rule.interval);
+          }
+        } else {
+          let monthlyString = getRString("monthlyDaysOfNth", [startDate.day]);
+          ruleString = PluralForm.get(rule.interval, monthlyString).replace("#2", rule.interval);
+        }
+      } else if (rule.type == "YEARLY") {
+        let bymonthday = null;
+        let bymonth = null;
+        if (checkRecurrenceRule(rule, ["BYMONTHDAY"])) {
+          bymonthday = rule.getComponent("BYMONTHDAY");
+        }
+        if (checkRecurrenceRule(rule, ["BYMONTH"])) {
+          bymonth = rule.getComponent("BYMONTH");
+        }
+        if (
+          (bymonth && bymonth.length > 1) ||
+          (bymonthday && (bymonthday.length > 1 || bymonthday[0] < -1))
+        ) {
+          // Don't build a string for a recurrence rule that the UI
+          // currently can't show completely (with more than one month
+          // or than one monthday, or bymonthdays lesser than -1).
+          return getRString("ruleTooComplex");
+        }
+
+        if (
+          checkRecurrenceRule(rule, ["BYMONTHDAY"]) &&
+          (checkRecurrenceRule(rule, ["BYMONTH"]) || !checkRecurrenceRule(rule, ["BYDAY"]))
+        ) {
+          // RRULE:FREQ=YEARLY;BYMONTH=x;BYMONTHDAY=y.
+          // RRULE:FREQ=YEARLY;BYMONTHDAY=x (takes the month from the start date).
+          let monthNumber = bymonth ? bymonth[0] : startDate.month + 1;
+          let month = getRString("repeatDetailsMonth" + monthNumber);
+          let monthDay =
+            bymonthday[0] == -1
+              ? getRString("monthlyLastDay")
+              : dateFormatter.formatDayWithOrdinal(bymonthday[0]);
+          let yearlyString = getRString("yearlyNthOn", [month, monthDay]);
+          ruleString = PluralForm.get(rule.interval, yearlyString).replace("#3", rule.interval);
+        } else if (checkRecurrenceRule(rule, ["BYMONTH"]) && checkRecurrenceRule(rule, ["BYDAY"])) {
+          // RRULE:FREQ=YEARLY;BYMONTH=x;BYDAY=y1,y2,....
+          let byday = rule.getComponent("BYDAY");
+          let month = getRString("repeatDetailsMonth" + bymonth[0]);
+          if (everyWeekDay(byday)) {
+            // Every day of the month.
+            let yearlyString = "yearlyEveryDayOf";
+            yearlyString = getRString(yearlyString, [month]);
+            ruleString = PluralForm.get(rule.interval, yearlyString).replace("#2", rule.interval);
+          } else if (byday.length == 1) {
+            let dayString = "repeatDetailsDay" + day_of_week(byday[0]);
+            if (day_position(byday[0]) == 0) {
+              // Every any weekday.
+              let yearlyString = "yearlyOnEveryNthOfNth";
+              yearlyString = nounClass(dayString, yearlyString);
+              let day = getRString(pluralWeekday(dayString));
+              yearlyString = getRString(yearlyString, [day, month]);
+              ruleString = PluralForm.get(rule.interval, yearlyString).replace("#3", rule.interval);
+            } else if (day_position(byday[0]) >= -1 || day_position(byday[0]) <= 5) {
+              // The first|the second|...|the last  Monday, Tuesday, ..., day.
+              let yearlyString = "yearlyNthOnNthOf";
+              yearlyString = nounClass(dayString, yearlyString);
+              let ordinalString = "repeatOrdinal" + day_position(byday[0]);
+              ordinalString = nounClass(dayString, ordinalString);
+              let ordinal = getRString(ordinalString);
+              let day = getRString(dayString);
+              yearlyString = getRString(yearlyString, [ordinal, day, month]);
+              ruleString = PluralForm.get(rule.interval, yearlyString).replace("#4", rule.interval);
+            } else {
+              return getRString("ruleTooComplex");
+            }
+          } else {
+            // Currently we don't support yearly rules with
+            // more than one BYDAY element or exactly 7 elements
+            // with all the weekdays (the "every day" case).
+            return getRString("ruleTooComplex");
+          }
+        } else if (checkRecurrenceRule(rule, ["BYMONTH"])) {
+          // RRULE:FREQ=YEARLY;BYMONTH=x (takes the day from the start date).
+          let month = getRString("repeatDetailsMonth" + bymonth[0]);
+          let yearlyString = getRString("yearlyNthOn", [month, startDate.day]);
+          ruleString = PluralForm.get(rule.interval, yearlyString).replace("#3", rule.interval);
+        } else {
+          let month = getRString("repeatDetailsMonth" + (startDate.month + 1));
+          let yearlyString = getRString("yearlyNthOn", [month, startDate.day]);
+          ruleString = PluralForm.get(rule.interval, yearlyString).replace("#3", rule.interval);
+        }
+      }
+
+      let kDefaultTimezone = cal.dtz.defaultTimezone;
+
+      let detailsString;
+      if (!endDate || allDay) {
+        if (rule.isFinite) {
+          if (rule.isByCount) {
+            let countString = getRString("repeatCountAllDay", [
+              ruleString,
+              dateFormatter.formatDateShort(startDate),
+            ]);
+
+            detailsString = PluralForm.get(rule.count, countString).replace("#3", rule.count);
+          } else {
+            let untilDate = rule.untilDate.getInTimezone(kDefaultTimezone);
+            detailsString = getRString("repeatDetailsUntilAllDay", [
+              ruleString,
+              dateFormatter.formatDateShort(startDate),
+              dateFormatter.formatDateShort(untilDate),
+            ]);
+          }
+        } else {
+          detailsString = getRString("repeatDetailsInfiniteAllDay", [
+            ruleString,
+            dateFormatter.formatDateShort(startDate),
+          ]);
+        }
+      } else if (rule.isFinite) {
+        if (rule.isByCount) {
+          let countString = getRString("repeatCount", [
+            ruleString,
+            dateFormatter.formatDateShort(startDate),
+            dateFormatter.formatTime(startDate),
+            dateFormatter.formatTime(endDate),
+          ]);
+          detailsString = PluralForm.get(rule.count, countString).replace("#5", rule.count);
+        } else {
+          let untilDate = rule.untilDate.getInTimezone(kDefaultTimezone);
+          detailsString = getRString("repeatDetailsUntil", [
+            ruleString,
+            dateFormatter.formatDateShort(startDate),
+            dateFormatter.formatDateShort(untilDate),
+            dateFormatter.formatTime(startDate),
+            dateFormatter.formatTime(endDate),
+          ]);
+        }
+      } else {
+        detailsString = getRString("repeatDetailsInfinite", [
+          ruleString,
+          dateFormatter.formatDateShort(startDate),
+          dateFormatter.formatTime(startDate),
+          dateFormatter.formatTime(endDate),
+        ]);
+      }
+      return detailsString;
+    }
+  }
+  return null;
+}
+
+/**
+ * Used to test if the recurrence items of a calIRecurrenceInfo instance are
+ * supported. We do not currently allow the "SECONDLY" or "MINUTELY" frequency
+ * values.
+ *
+ * @param {calIRecurrenceInfo} recurrenceInfo
+ * @returns {boolean}
+ */
+function hasUnsupported(recurrenceInfo) {
+  return recurrenceInfo
+    .getRecurrenceItems()
+    .some(item => item.type == "SECONDLY" || item.type == "MINUTELY");
+}
+
+/**
+ * Split rules into negative and positive rules.
+ *
+ * @param recurrenceInfo    An item's recurrence info to parse.
+ * @returns An array with two elements: an array of positive
+ *                            rules and an array of negative rules.
+ */
+function splitRecurrenceRules(recurrenceInfo) {
+  let ritems = recurrenceInfo.getRecurrenceItems();
+  let rules = [];
+  let exceptions = [];
+  for (let ritem of ritems) {
+    if (ritem.isNegative) {
+      exceptions.push(ritem);
+    } else {
+      rules.push(ritem);
+    }
+  }
+  return [rules, exceptions];
+}
+
+/**
+ * Check if a recurrence rule's component is valid.
+ *
+ * @see                     calIRecurrenceRule
+ * @param aRule             The recurrence rule to check.
+ * @param aArray            An array of component names to check.
+ * @returns Returns true if the rule is valid.
+ */
+function checkRecurrenceRule(aRule, aArray) {
+  for (let comp of aArray) {
+    let ruleComp = aRule.getComponent(comp);
+    if (ruleComp && ruleComp.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Counts the occurrences of the parent item if any of a provided item
+ *
+ * @param  {(calIEvent|calIToDo)}  aItem  item to count for
+ * @returns {(number|null)} number of occurrences or null if the
+ *                                          passed item's parent item isn't a
+ *                                          recurring item or its recurrence is
+ *                                          infinite
+ */
+function countOccurrences(aItem) {
+  let occCounter = null;
+  let recInfo = aItem.parentItem.recurrenceInfo;
+  if (recInfo && recInfo.isFinite) {
+    occCounter = 0;
+    let excCounter = 0;
+    let byCount = false;
+    let ritems = recInfo.getRecurrenceItems();
+    for (let ritem of ritems) {
+      if (ritem instanceof lazy.CalRecurrenceRule || ritem instanceof Ci.calIRecurrenceRule) {
+        if (ritem.isByCount) {
+          occCounter = occCounter + ritem.count;
+          byCount = true;
+        } else {
+          // The rule is limited by an until date.
+          let parentItem = aItem.parentItem;
+          let startDate = parentItem.startDate ?? parentItem.entryDate;
+          let endDate = parentItem.endDate ?? parentItem.dueDate ?? startDate;
+          let from = startDate.clone();
+          let until = endDate.clone();
+          if (until.compare(ritem.untilDate) == -1) {
+            until = ritem.untilDate.clone();
+          }
+
+          let exceptionIds = recInfo.getExceptionIds();
+          for (let exceptionId of exceptionIds) {
+            let recur = recInfo.getExceptionFor(exceptionId);
+            let recurStartDate = recur.startDate ?? recur.entryDate;
+            let recurEndDate = recur.endDate ?? recur.dueDate ?? recurStartDate;
+            if (from.compare(recurStartDate) == 1) {
+              from = recurStartDate.clone();
+            }
+            if (until.compare(recurEndDate) == -1) {
+              until = recurEndDate.clone();
+            }
+          }
+
+          // we add an extra day at beginning and end, so we don't
+          // need to take care of any timezone conversion
+          from.addDuration(cal.createDuration("-P1D"));
+          until.addDuration(cal.createDuration("P1D"));
+
+          let occurrences = recInfo.getOccurrences(from, until, 0);
+          occCounter = occCounter + occurrences.length;
+        }
+      } else if (
+        ritem instanceof lazy.CalRecurrenceDate ||
+        ritem instanceof Ci.calIRecurrenceDate
+      ) {
+        if (ritem.isNegative) {
+          // this is an exdate
+          excCounter++;
+        } else {
+          // this is an (additional) rdate
+          occCounter++;
+        }
+      }
+    }
+
+    if (byCount) {
+      // for a rrule by count, we still need to subtract exceptions if any
+      occCounter = occCounter - excCounter;
+    }
+  }
+  return occCounter;
+}