');
+
+ assert.strictEqual(attendee.name(), 'Zac');
+ assert.strictEqual(attendee.email(), 'zac@example.com');
+ assert.strictEqual(event.attendees().length, 1, 'attendee pushed');
+ });
+
+ it('should throw error when string misformated', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ e.createAttendee('foo bar');
+ }, /isn't formated correctly/);
+ });
+
+ it('should accept object', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const attendee = event.createAttendee({name: 'Zac', email: 'zac@example.com'});
+
+ assert.strictEqual(attendee.name(), 'Zac');
+ assert.strictEqual(attendee.email(), 'zac@example.com');
+ assert.strictEqual(event.attendees().length, 1, 'attendee pushed');
+ });
+ });
+
+ describe('attendees()', function () {
+ it('getter should return an array of attendees…', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.attendees().length, 0);
+
+ const attendee = event.createAttendee({ email: 'mail@example.com' });
+ assert.strictEqual(event.attendees().length, 1);
+ assert.deepStrictEqual(event.attendees()[0], attendee);
+ });
+
+ it('setter should add attendees and return this', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const foo = event.attendees([
+ { name: 'Person A', email: 'a@example.com' },
+ { name: 'Person B', email: 'b@example.com' }
+ ]);
+
+ assert.strictEqual(event.attendees().length, 2);
+ assert.deepStrictEqual(foo, event);
+ });
+ });
+
+ describe('createAlarm()', function () {
+ it('should return a ICalAlarm instance', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+
+ assert.ok(event.createAlarm({
+ type: ICalAlarmType.display,
+ trigger: 60 * 10
+ }) instanceof ICalAlarm);
+ });
+
+ it('should pass data to instance', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const alarm = event.createAlarm({
+ type: ICalAlarmType.audio,
+ trigger: 60 * 10
+ });
+
+ assert.strictEqual(alarm.type(), 'audio');
+ });
+ });
+
+ describe('alarms()', function () {
+ it('getter should return an array of alarms…', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.alarms().length, 0);
+
+ const alarm = event.createAlarm({
+ type: ICalAlarmType.display,
+ trigger: 600
+ });
+ assert.strictEqual(event.alarms().length, 1);
+ assert.deepStrictEqual(event.alarms()[0], alarm);
+ });
+
+ it('setter should add alarms and return this', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const foo = event.alarms([
+ { type: ICalAlarmType.audio, trigger: 60 },
+ { type: ICalAlarmType.display, trigger: 600 }
+ ]);
+
+ assert.strictEqual(event.alarms().length, 2);
+ assert.deepStrictEqual(foo, event);
+ });
+ });
+
+ describe('createCategory()', function () {
+ it('should return a ICalCategory instance', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.ok(event.createCategory({ name: 'Test' }) instanceof ICalCategory);
+ });
+
+ it('should pass data to instance', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const category = event.createCategory({name: 'foo'});
+
+ assert.strictEqual(category.name(), 'foo');
+ });
+ });
+
+ describe('categories()', function () {
+ it('getter should return an array of categories…', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.categories().length, 0);
+
+ const category = event.createCategory({ name: 'Test' });
+ assert.strictEqual(event.categories().length, 1);
+ assert.deepStrictEqual(event.categories()[0], category);
+ });
+
+ it('setter should add category and return this', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const foo = event.categories([
+ {name: 'foo'},
+ {name: 'bar'}
+ ]);
+
+ assert.strictEqual(event.categories().length, 2);
+ assert.deepStrictEqual(foo, event);
+ });
+ });
+
+ describe('status()', function () {
+ it('getter should return value', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.status(), null);
+
+ event.status(ICalEventStatus.CONFIRMED);
+ assert.strictEqual(event.status(), 'CONFIRMED');
+
+ event.status(null);
+ assert.strictEqual(event.status(), null);
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.status(null));
+ assert.deepStrictEqual(e, e.status(ICalEventStatus.CONFIRMED));
+ });
+
+ it('setter should allow setting null', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.status(ICalEventStatus.CONFIRMED);
+ e.status(null);
+ assert.strictEqual(e.status(), null);
+ });
+
+ it('setter should allow setting valid value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.status(ICalEventStatus.CONFIRMED);
+ assert.strictEqual(e.status(), 'CONFIRMED');
+ assert.strictEqual(e.status(), ICalEventStatus.CONFIRMED);
+ });
+
+ it('should throw error when method not allowed', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ // @ts-ignore
+ e.status('COOKING');
+ }, /Input must be one of the following: CONFIRMED, TENTATIVE, CANCELLED/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.status(Infinity);
+ }, /Input must be one of the following: CONFIRMED, TENTATIVE, CANCELLED/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.status(NaN);
+ }, /Input must be one of the following: CONFIRMED, TENTATIVE, CANCELLED/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.status(-1);
+ }, /Input must be one of the following: CONFIRMED, TENTATIVE, CANCELLED/);
+ });
+ });
+
+ describe('busystatus()', function () {
+ it('getter should return value', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.busystatus(), null);
+
+ event.busystatus(ICalEventBusyStatus.BUSY);
+ assert.strictEqual(event.busystatus(), 'BUSY');
+
+ event.busystatus(null);
+ assert.strictEqual(event.busystatus(), null);
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.busystatus(null));
+ assert.deepStrictEqual(e, e.busystatus(ICalEventBusyStatus.BUSY));
+ });
+
+ it('setter should allow setting null', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.busystatus(ICalEventBusyStatus.BUSY);
+ e.busystatus(null);
+ assert.strictEqual(e.busystatus(), null);
+ });
+
+ it('setter should allow setting valid value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.busystatus(ICalEventBusyStatus.BUSY);
+ assert.strictEqual(e.busystatus(), 'BUSY');
+ });
+
+ it('should throw error when method not allowed', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ // @ts-ignore
+ e.busystatus('COOKING');
+ }, /FREE, TENTATIVE, BUSY, OOF/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.busystatus(Infinity);
+ }, /FREE, TENTATIVE, BUSY, OOF/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.busystatus(NaN);
+ }, /FREE, TENTATIVE, BUSY, OOF/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.busystatus(-1);
+ }, /FREE, TENTATIVE, BUSY, OOF/);
+ });
+ });
+
+ describe('priority()', function () {
+ it('getter should return value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(e.priority(), null);
+
+ e.priority(5);
+ assert.strictEqual(e.priority(), 5);
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.priority(null));
+ assert.deepStrictEqual(e, e.priority(5));
+ });
+
+ it('should update value', function () {
+ const event = new ICalEvent({
+ start: moment(),
+ summary: 'Example Event'
+ }, new ICalCalendar());
+
+ event.priority(5);
+ assert.strictEqual(event.priority(), 5);
+ assert.ok(event.toString().includes('PRIORITY:5'));
+ });
+ });
+
+ describe('url()', function () {
+ it('getter should return value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(e.url(), null);
+
+ e.url('http://sebbo.net/');
+ assert.strictEqual(e.url(), 'http://sebbo.net/');
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.url(null));
+ assert.deepStrictEqual(e, e.url('http://sebbo.net/'));
+ });
+
+ it('should update value', function () {
+ const event = new ICalEvent({
+ start: moment(),
+ summary: 'Example Event'
+ }, new ICalCalendar());
+
+ event.url('http://github.com/sebbo2002/ical-generator');
+ assert.strictEqual(event.url(), 'http://github.com/sebbo2002/ical-generator');
+ });
+ });
+
+ describe('createAttachment()', function () {
+ it('should return this', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(event.createAttachment('https://files.sebbo.net/calendar/attachments/foo'), event);
+ });
+ });
+
+ describe('attachments()', function () {
+ it('getter should return an array of strings…', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.attachments().length, 0);
+
+ event.createAttachment('https://files.sebbo.net/calendar/attachments/foo');
+ assert.strictEqual(event.attachments().length, 1);
+ assert.deepStrictEqual(typeof event.attachments()[0], 'string');
+ });
+
+ it('setter should add url and return this', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const foo = event.attachments([
+ 'https://files.sebbo.net/calendar/attachments/foo',
+ 'https://files.sebbo.net/calendar/attachments/bar'
+ ]);
+
+ assert.strictEqual(event.attachments().length, 2);
+ assert.deepStrictEqual(foo, event);
+ });
+ });
+
+ describe('created()', function () {
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.created(new Date()));
+ });
+
+ it('setter should work with moment', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.created(moment());
+ assert.ok(moment.isMoment(e.created()));
+ });
+
+ it('setter should work with Date', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.created(new Date());
+ assert.ok(e.created() instanceof Date);
+ });
+
+ it('setter should work with String', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.created(moment().toJSON());
+ assert.strictEqual(typeof e.created(), 'string');
+ });
+
+ it('setter should work with Number', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.created(new Date());
+ assert.ok(e.created() instanceof Date);
+ });
+
+ it('getter should return value', function () {
+ const now = new Date();
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar())
+ .created(now);
+
+ assert.deepStrictEqual(e.created()?.valueOf(), now.getTime());
+ });
+
+ it('should throw error when created is not a Date', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ e.created('hallo'); // this will produce a "Deprecation warning", sorry 😇
+ }, /`created`/);
+ });
+ });
+
+ describe('lastModified()', function () {
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.lastModified(new Date()));
+ });
+
+ it('setter should work with moment', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.lastModified(moment());
+ assert.ok(moment.isMoment(e.lastModified()));
+ });
+
+ it('setter should work with Date', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.lastModified(new Date());
+ assert.ok(e.lastModified() instanceof Date);
+ });
+
+ it('setter should work with String', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ const date = moment().toJSON();
+ e.lastModified(date);
+ assert.strictEqual(e.lastModified(), date);
+ });
+
+ it('setter should work with Number', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.lastModified(new Date());
+ assert.ok(e.lastModified() instanceof Date);
+ });
+
+ it('getter should return value', function () {
+ const now = new Date();
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar())
+ .lastModified(now);
+
+ assert.deepStrictEqual(e.lastModified()?.valueOf(), now.getTime());
+ });
+
+ it('should throw error when lastModified is not a Date', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ e.lastModified('hallo');
+ }, /`lastModified`/);
+ });
+ });
+
+ describe('class()', function () {
+ it('getter should return value', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.class(), null);
+
+ event.class(ICalEventClass.PRIVATE);
+ assert.strictEqual(event.class(), 'PRIVATE');
+
+ event.class(null);
+ assert.strictEqual(event.class(), null);
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.class(null));
+ assert.deepStrictEqual(e, e.class(ICalEventClass.PRIVATE));
+ });
+
+ it('setter should allow setting null', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.class(ICalEventClass.PRIVATE);
+ e.class(null);
+ assert.strictEqual(e.class(), null);
+ });
+
+ it('setter should allow setting valid value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.class(ICalEventClass.PRIVATE);
+ assert.strictEqual(e.class(), 'PRIVATE');
+ assert.strictEqual(e.class(), ICalEventClass.PRIVATE);
+ });
+
+ it('should throw error when method not allowed', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ // @ts-ignore
+ e.class('COOKING');
+ }, /Input must be one of the following: PUBLIC, PRIVATE, CONFIDENTIAL/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.class(Infinity);
+ }, /Input must be one of the following: PUBLIC, PRIVATE, CONFIDENTIAL/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.class(NaN);
+ }, /Input must be one of the following: PUBLIC, PRIVATE, CONFIDENTIAL/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.class(-1);
+ }, /Input must be one of the following: PUBLIC, PRIVATE, CONFIDENTIAL/);
+ });
+ });
+
+ describe('x()', function () {
+ it('is there', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.x('X-FOO', 'bar'));
+ });
+ });
+
+ describe('toJSON()', function () {
+ it('should maybe work', function () {
+ const date = moment().add(1, 'month');
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar())
+ .summary('foo')
+ .start(date);
+
+ assert.strictEqual(event.toJSON().summary, 'foo', 'summary is okay');
+ assert.deepStrictEqual(event.toJSON().start, date.toJSON(), 'start is okay');
+ assert.strictEqual(typeof event.toJSON().start, 'string', 'start is string');
+ });
+
+ it('should stringify RRule objects', function() {
+ const date = new Date();
+ const rule = new rrule.RRule({
+ freq: rrule.RRule.WEEKLY,
+ interval: 5,
+ byweekday: [rrule.RRule.MO, rrule.RRule.FR],
+ dtstart: date,
+ until: new Date(Date.UTC(2012, 12, 31))
+ });
+
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar())
+ .summary('foo')
+ .start(date)
+ .repeating(rule);
+
+ const json = event.toJSON();
+ const before = event.toString();
+ assert.ok(typeof json.repeating === 'string');
+
+ const event2 = new ICalEvent(event.toJSON(), new ICalCalendar());
+ const after = event2.toString();
+ assert.strictEqual(after, before);
+ });
+
+ it('should be compatible with constructor (type check)', function () {
+ const a = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ new ICalEvent(a.toJSON(), new ICalCalendar());
+ });
+ });
+
+ describe('transparency()', function () {
+ it('getter should return value', function () {
+ const event = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.strictEqual(event.transparency(), null);
+
+ event.transparency(ICalEventTransparency.OPAQUE);
+ assert.strictEqual(event.transparency(), 'OPAQUE');
+
+ event.transparency(null);
+ assert.strictEqual(event.transparency(), null);
+ });
+
+ it('setter should return this', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.deepStrictEqual(e, e.transparency(null));
+ assert.deepStrictEqual(e, e.transparency(ICalEventTransparency.TRANSPARENT));
+ });
+
+ it('setter should allow setting null', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.transparency(ICalEventTransparency.OPAQUE);
+ e.transparency(null);
+ assert.strictEqual(e.transparency(), null);
+ });
+
+ it('setter should allow setting valid value', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ e.transparency(ICalEventTransparency.OPAQUE);
+ assert.strictEqual(e.transparency(), 'OPAQUE');
+ });
+
+ it('should throw error when method not allowed', function () {
+ const e = new ICalEvent({ start: new Date() }, new ICalCalendar());
+ assert.throws(function () {
+ // @ts-ignore
+ e.transparency('COOKING');
+ }, /TRANSPARENT, OPAQUE/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.transparency(Infinity);
+ }, /TRANSPARENT, OPAQUE/);
+ assert.throws(function () {
+ // @ts-ignore
+ e.transparency(-1);
+ }, /TRANSPARENT, OPAQUE/);
+ });
+ });
+
+ describe('toString()', function () {
+ it('should make use of escaping', function () {
+ const e = new ICalEvent({
+ start: new Date(),
+ end: new Date(new Date().getTime() + 3600000),
+ summary: 'Hel\\\\lo\nW;orl,d'
+ }, new ICalCalendar());
+
+ assert.ok(e.toString().indexOf('Hel\\\\\\\\lo\\nW\\;orl\\,d') > -1);
+ });
+
+ it('should render correct UIDs', function () {
+ const cal = new ICalCalendar();
+ const event = new ICalEvent({
+ id: 42,
+ start: moment(),
+ summary: ':)'
+ }, cal);
+
+ assert.ok(event.toString().indexOf('UID:42\r') > -1);
+ });
+
+ it('should include wkst only if provided', function () {
+ const cal = new ICalCalendar();
+ let event = new ICalEvent({
+ start: moment(),
+ end: moment(),
+ repeating: {
+ freq: ICalEventRepeatingFreq.WEEKLY
+ }
+ }, cal);
+ assert.ok(!event.toString().includes('WKST'), 'without WKST');
+
+ event = new ICalEvent({
+ start: moment(),
+ end: moment(),
+ repeating: {
+ freq: ICalEventRepeatingFreq.WEEKLY,
+ startOfWeek: ICalWeekday.SU
+ }
+ }, cal);
+ assert.ok(event.toString().includes('WKST'), 'with WKST');
+ });
+
+ it('should render allday events for luxon dates with timezone correct', function () {
+ const cal = new ICalCalendar();
+ const luxonStartDate = DateTime.fromISO('2024-03-17T00:00:00.000+01:00', {setZone: true});
+ const luxonEndDate = DateTime.fromISO('2024-03-18T00:00:00.000+01:00', {setZone: true});
+ const event = new ICalEvent({
+ allDay: true,
+ start: luxonStartDate,
+ end: luxonEndDate,
+ }, cal);
+
+ const actual = event.toString();
+ assert.match(actual, new RegExp('X-MICROSOFT-CDO-ALLDAYEVENT:TRUE\r\n'), 'with Microsoft CDO alldayevent set');
+ assert.match(actual, new RegExp('X-MICROSOFT-MSNCALENDAR-ALLDAYEVENT:TRUE\r\n'), 'with Microsoft MSNCalendar alldayevent flag set');
+ assert.match(actual, new RegExp(`DTSTART;VALUE=DATE:${luxonStartDate.toFormat('yyyyLLdd')}\r\n`), 'for DTSTART');
+ assert.match(actual, new RegExp(`DTEND;VALUE=DATE:${luxonEndDate.toFormat('yyyyLLdd')}\r\n`), 'for DTEND');
+ });
+ });
+});
diff --git a/test/index.ts b/test/index.ts
new file mode 100644
index 000000000..c6192bb77
--- /dev/null
+++ b/test/index.ts
@@ -0,0 +1,114 @@
+'use strict';
+
+import assert from 'assert';
+import ical, {
+ ICalAlarm,
+ ICalAlarmType,
+ ICalAttendee,
+ ICalAttendeeType,
+ ICalAttendeeRole,
+ ICalAttendeeStatus,
+ ICalCategory,
+ ICalCalendar,
+ ICalCalendarMethod,
+ ICalEvent,
+ ICalEventStatus,
+ ICalEventBusyStatus,
+ ICalEventTransparency,
+ ICalEventRepeatingFreq,
+ ICalWeekday,
+ formatDate,
+ formatDateTZ,
+ escape,
+ foldLines
+} from '../src/index.js';
+
+describe('ical-generator Index', function() {
+ describe('default', function () {
+ it('should be a function', function() {
+ assert.strictEqual(typeof ical, 'function');
+ });
+ it('should return a ICalCalendar', function() {
+ assert.ok(ical() instanceof ICalCalendar);
+ });
+ });
+
+ describe('Alarm', function () {
+ it('should export ICalAlarm', function () {
+ assert.ok(ICalAlarm);
+ });
+ it('should export ICalAlarmType', function () {
+ assert.ok(ICalAlarmType);
+ });
+ });
+
+ describe('Attendee', function () {
+ it('should export ICalAttendee', function () {
+ assert.ok(ICalAttendee);
+ });
+ it('should export ICalAttendeeType', function () {
+ assert.ok(ICalAttendeeType);
+ });
+ it('should export ICalAttendeeRole', function () {
+ assert.ok(ICalAttendeeRole);
+ });
+ it('should export ICalAttendeeStatus', function () {
+ assert.ok(ICalAttendeeStatus);
+ });
+ });
+
+ describe('Calendar', function () {
+ it('should export ICalCalendar', function() {
+ assert.ok(ICalCalendar);
+ });
+
+ it('should export ICalCalendarMethod', function() {
+ assert.ok(ICalCalendarMethod);
+ });
+ });
+
+ describe('Category', function () {
+ it('should export ICalCategory', function () {
+ assert.ok(ICalCategory);
+ });
+ });
+
+ describe('Event', function () {
+ it('should export ICalEvent', function() {
+ assert.ok(ICalEvent);
+ });
+ it('should export ICalEventStatus', function() {
+ assert.ok(ICalEventStatus);
+ });
+ it('should export ICalEventBusyStatus', function() {
+ assert.ok(ICalEventBusyStatus);
+ });
+ it('should export ICalEventTransparency', function() {
+ assert.ok(ICalEventTransparency);
+ });
+ });
+
+ describe('Type', function () {
+ it('should export ICalEventRepeatingFreq', function () {
+ assert.ok(ICalEventRepeatingFreq);
+ });
+ it('should export ICalWeekday', function () {
+ assert.ok(ICalWeekday);
+ });
+ });
+
+ describe('Tools', function () {
+ it('should export formatDate', function () {
+ assert.ok(typeof formatDate === 'function');
+ });
+ it('should export formatDateTZ', function () {
+ assert.ok(typeof formatDateTZ === 'function');
+ });
+ it('should export escape', function () {
+ assert.ok(typeof escape === 'function');
+ });
+ it('should export foldLines', function () {
+ assert.ok(typeof foldLines === 'function');
+ });
+ });
+});
diff --git a/test/issues.ts b/test/issues.ts
new file mode 100644
index 000000000..3acf22607
--- /dev/null
+++ b/test/issues.ts
@@ -0,0 +1,327 @@
+'use strict';
+
+import assert from 'assert';
+import moment from 'moment-timezone';
+import ical from '../src/index.js';
+import {ICalEventRepeatingFreq, ICalWeekday} from '../src/types.js';
+
+describe('Issues', function () {
+ describe('Issue #38', function () {
+ it('should work with Europe/Berlin', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ timezone: 'Europe/Berlin',
+ events: [{
+ start: moment('2016-04-30T22:00:00.000Z'),
+ summary: 'Example Event',
+ allDay: true
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('DTSTART;VALUE=DATE:20160501') > -1);
+ });
+ it('should work with Brazil/East', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ timezone: 'Brazil/East',
+ events: [{
+ start: moment('2016-05-01T03:00:00.000Z'),
+ summary: 'Example Event',
+ allDay: true
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('DTSTART;VALUE=DATE:20160501') > -1);
+ });
+ });
+
+ describe('Issue #123', function () {
+ it('should work with repeating bySetPos', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ events: [{
+ start: moment('2016-04-30T22:00:00.000Z'),
+ end: moment('2016-05-01T00:00:00.000Z'),
+ summary: 'Example Event',
+ allDay: true,
+ repeating: {
+ freq: ICalEventRepeatingFreq.MONTHLY,
+ count: 3,
+ interval: 1,
+ byDay: [ICalWeekday.SU],
+ bySetPos: 3
+ }
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('RRULE:FREQ=MONTHLY;COUNT=3;INTERVAL=1;BYDAY=SU;BYSETPOS=3') > -1);
+ });
+
+ it('should work with repeating bySetPos by taking all elements of the byDay array', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ events: [{
+ start: moment('2016-04-30T22:00:00.000Z'),
+ end: moment('2016-05-01T00:00:00.000Z'),
+ summary: 'Example Event',
+ allDay: true,
+ repeating: {
+ freq: ICalEventRepeatingFreq.MONTHLY,
+ count: 3,
+ interval: 1,
+ byDay: [ICalWeekday.MO, ICalWeekday.FR],
+ bySetPos: 3
+ }
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('RRULE:FREQ=MONTHLY;COUNT=3;INTERVAL=1;BYDAY=MO,FR;BYSETPOS=3') > -1);
+ });
+ });
+
+ describe('Issue #154', function () {
+ ['DTSTART', 'DTEND', 'RECURRENCE-ID'].forEach(function (prop) {
+ it(`it should correctly set ${prop} when using different timezone in calendar and event`, function () {
+ const calendar = ical({
+ timezone: 'America/Buenos_Aires',
+ events: [
+ {
+ start: moment(1553219772000),
+ end: moment(1553219772000),
+ recurrenceId: moment(1553219772000),
+ timezone: 'America/La_Paz'
+ }
+ ]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf(`${prop};TZID=America/La_Paz:20190321T215612`) > -1, str);
+ });
+ });
+ });
+
+ describe('Issue #210', function () {
+ it('should repeat/exclude with Europe/Berlin', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ timezone: 'Europe/Berlin',
+ events: [{
+ start: moment('2020-08-13T00:00:00+01:00'),
+ summary: 'Example Event',
+ repeating: {
+ freq: ICalEventRepeatingFreq.MONTHLY,
+ count: 12,
+ exclude: moment('2020-12-13T00:00:00+01:00')
+ }
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('EXDATE;TZID=Europe/Berlin:20201213T000000') > -1);
+ });
+ it('should repeat/exclude with America/New_York', function () {
+ const calendar = ical({
+ prodId: '//superman-industries.com//ical-generator//EN',
+ timezone: 'America/New_York',
+ events: [{
+ start: moment('2020-08-13T00:00:00-05:00'),
+ summary: 'Example Event',
+ repeating: {
+ freq: ICalEventRepeatingFreq.MONTHLY,
+ count: 12,
+ exclude: moment('2020-12-13T00:00:00-05:00')
+ }
+ }]
+ });
+
+ const str = calendar.toString();
+ assert.ok(str.indexOf('EXDATE;TZID=America/New_York:20201213T000000') > -1);
+ });
+ });
+
+ describe('Issue #236', function () {
+ it('should look like in the example', function () {
+ const calendar = ical({
+ events: [{
+ id: 'foo',
+ start: new Date('2020-08-13T00:00:00-05:00'),
+ stamp: new Date('2020-08-13T00:00:00-05:00'),
+ summary: 'Example Event',
+ location: {
+ title: 'Los Angeles, California, United States',
+ geo: {
+ lon: -118.24368,
+ lat: 34.05223,
+ },
+ radius: 400
+ }
+ }]
+ });
+
+ assert.strictEqual(calendar.toString(), [
+ 'BEGIN:VCALENDAR',
+ 'VERSION:2.0',
+ 'PRODID:-//sebbo.net//ical-generator//EN',
+ 'BEGIN:VEVENT',
+ 'UID:foo',
+ 'SEQUENCE:0',
+ 'DTSTAMP:20200813T050000Z',
+ 'DTSTART:20200813T050000Z',
+ 'SUMMARY:Example Event',
+ 'LOCATION:Los Angeles\\, California\\, United States',
+ 'X-APPLE-STRUCTURED-LOCATION;VALUE=URI;X-APPLE-RADIUS=400;X-TITLE=Los Angel',
+ ' es\\, California\\, United States:geo:34.05223,-118.24368',
+ 'GEO:34.05223;-118.24368',
+ 'END:VEVENT',
+ 'END:VCALENDAR'
+ ].join('\r\n'));
+ });
+ });
+
+ describe('Issue #377', function () {
+ it('should not escape quotes in summary', function () {
+ const calendar = ical({
+ events: [
+ {
+ id: 'foo',
+ start: new Date('2020-08-13T00:00:00-05:00'),
+ stamp: new Date('2020-08-13T00:00:00-05:00'),
+ summary:'My "quoted" string'
+ }
+ ]
+ });
+
+ assert.strictEqual(calendar.toString(), [
+ 'BEGIN:VCALENDAR',
+ 'VERSION:2.0',
+ 'PRODID:-//sebbo.net//ical-generator//EN',
+ 'BEGIN:VEVENT',
+ 'UID:foo',
+ 'SEQUENCE:0',
+ 'DTSTAMP:20200813T050000Z',
+ 'DTSTART:20200813T050000Z',
+ 'SUMMARY:My "quoted" string',
+ 'END:VEVENT',
+ 'END:VCALENDAR'
+ ].join('\r\n'));
+ });
+ });
+
+ describe('Issue #442', function () {
+ it('should generate floating repeat until value if event is a floating event');
+ it('should generate floating repeat exclusion dates if event is a floating event');
+ });
+
+ describe('Issue #459', function () {
+ it('event.repeating should work with `RRULE:` prefix', function () {
+ const calendar = ical({
+ events: [{
+ id: 'foo',
+ start: new Date('2020-08-13T00:00:00-05:00'),
+ stamp: new Date('2020-08-13T00:00:00-05:00'),
+ summary: 'Example Event',
+ repeating: 'RRULE:FREQ=MONTHLY;COUNT=3;INTERVAL=1'
+ }]
+ });
+
+ assert.strictEqual(calendar.toString(), [
+ 'BEGIN:VCALENDAR',
+ 'VERSION:2.0',
+ 'PRODID:-//sebbo.net//ical-generator//EN',
+ 'BEGIN:VEVENT',
+ 'UID:foo',
+ 'SEQUENCE:0',
+ 'DTSTAMP:20200813T050000Z',
+ 'DTSTART:20200813T050000Z',
+ 'RRULE:FREQ=MONTHLY;COUNT=3;INTERVAL=1',
+ 'SUMMARY:Example Event',
+ 'END:VEVENT',
+ 'END:VCALENDAR'
+ ].join('\r\n'));
+ });
+ it('event.repeating should work without `RRULE:` prefix', function () {
+ const calendar = ical({
+ events: [{
+ id: 'foo',
+ start: new Date('2020-08-13T00:00:00-05:00'),
+ stamp: new Date('2020-08-13T00:00:00-05:00'),
+ summary: 'Example Event',
+ repeating: 'FREQ=MONTHLY;COUNT=3;INTERVAL=1'
+ }]
+ });
+
+ assert.strictEqual(calendar.toString(), [
+ 'BEGIN:VCALENDAR',
+ 'VERSION:2.0',
+ 'PRODID:-//sebbo.net//ical-generator//EN',
+ 'BEGIN:VEVENT',
+ 'UID:foo',
+ 'SEQUENCE:0',
+ 'DTSTAMP:20200813T050000Z',
+ 'DTSTART:20200813T050000Z',
+ 'RRULE:FREQ=MONTHLY;COUNT=3;INTERVAL=1',
+ 'SUMMARY:Example Event',
+ 'END:VEVENT',
+ 'END:VCALENDAR'
+ ].join('\r\n'));
+ });
+ });
+
+ describe('Issue #569 / 570', function () {
+ it('event.location should work with `geo` only', function () {
+ const event = ical().createEvent({
+ id: '12345',
+ summary: 'Hello',
+ start: new Date('2020-06-15T00:00:00Z'),
+ end: new Date('2020-06-15T01:00:00Z'),
+ stamp: new Date('2020-06-15T00:00:00Z')
+ });
+
+ event.location({
+ geo: {
+ lat: 52.51147570081018,
+ lon: 13.342200696373846
+ }
+ });
+
+ assert.strictEqual(event.toString(), [
+ 'BEGIN:VEVENT',
+ 'UID:12345',
+ 'SEQUENCE:0',
+ 'DTSTAMP:20200615T000000Z',
+ 'DTSTART:20200615T000000Z',
+ 'DTEND:20200615T010000Z',
+ 'SUMMARY:Hello',
+ 'GEO:52.51147570081018;13.342200696373846',
+ 'END:VEVENT',
+ ''
+ ].join('\r\n'));
+ });
+ });
+
+ describe('Issue #581', function () {
+ it('event.start and event.end should be swappable', function () {
+ const calendar = ical();
+ const event = calendar.createEvent({
+ summary: 'Test Event',
+ start: '2024-02-29T17:00:00.000Z',
+ end: '2024-02-29T17:20:00.000Z'
+ });
+
+ event.start('2024-02-29T19:00:00.000Z');
+ event.end('2024-02-29T19:20:00.000Z');
+
+ const start = event.start();
+ assert.ok(typeof start === 'string');
+ assert.strictEqual(start, '2024-02-29T19:00:00.000Z');
+
+ const end = event.end();
+ assert.ok(typeof end === 'string');
+ assert.strictEqual(end, '2024-02-29T19:20:00.000Z');
+ });
+ });
+});
diff --git a/test/lib/index.ts b/test/lib/index.ts
deleted file mode 100644
index 6ac7aa3fd..000000000
--- a/test/lib/index.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-'use strict';
-
-import Magic from '../../src/lib/index.js';
-import assert from 'assert';
-
-describe('Example', function () {
- it('should work with integers', function () {
- assert.strictEqual(Magic.double(2), 4);
- });
-});
diff --git a/test/results/generate_01.ics b/test/results/generate_01.ics
new file mode 100755
index 000000000..19d0a4f9c
--- /dev/null
+++ b/test/results/generate_01.ics
@@ -0,0 +1,14 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131004T231500Z
+SUMMARY:Simple Event
+CREATED:20131004T233453Z
+LAST-MODIFIED:20131004T233453Z
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_02.ics b/test/results/generate_02.ics
new file mode 100755
index 000000000..ccd953fa8
--- /dev/null
+++ b/test/results/generate_02.ics
@@ -0,0 +1,20 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131004T231500Z
+SUMMARY:Sample Event
+TRANSP:OPAQUE
+LOCATION:localhost
+DESCRIPTION:Lorem ipsum dolor sit amet\, consetetur sadipscing elitr\, sed
+ diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam era
+ t\, sed diam voluptua.\nbeep boop
+X-ALT-DESC;FMTTYPE=text/html:Lorem ipsum dolor sit amet\, consetetur sa
+ dipscing elitr\, sed diam nonumy eirmod tempor invidunt ut labore et dolor
+ e magna aliquyam erat\, sed diam voluptua.\nbeep boop
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_03.ics b/test/results/generate_03.ics
new file mode 100755
index 000000000..90e9ab0b3
--- /dev/null
+++ b/test/results/generate_03.ics
@@ -0,0 +1,26 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+METHOD:ADD
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART;VALUE=DATE:20131004
+DTEND;VALUE=DATE:20131006
+X-MICROSOFT-CDO-ALLDAYEVENT:TRUE
+X-MICROSOFT-MSNCALENDAR-ALLDAYEVENT:TRUE
+SUMMARY:Sample Event
+LOCATION:Apple Store Kurfürstendamm\nKurfürstendamm 26\, 10719 Berlin\,
+ Deutschland
+X-APPLE-STRUCTURED-LOCATION;VALUE=URI;X-ADDRESS=Kurfürstendamm 26\, 10719
+ Berlin\, Deutschland;X-APPLE-RADIUS=141.1751386318387;X-TITLE=Apple Store
+ Kurfürstendamm:geo:52.50363,13.32865
+GEO:52.50363;13.32865
+ORGANIZER;CN="Sebastian Pekarek":mailto:mail@sebbo.net
+CATEGORIES:WORK
+URL;VALUE=URI:http://sebbo.net/
+ATTACH:https://files.sebbo.net/calendar/attachments/foo
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_04.ics b/test/results/generate_04.ics
new file mode 100755
index 000000000..5bd6e562b
--- /dev/null
+++ b/test/results/generate_04.ics
@@ -0,0 +1,51 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VTIMEZONE
+TZID:Europe/Berlin
+TZURL:http://tzurl.org/zoneinfo-outlook/Europe/Berlin
+X-LIC-LOCATION:Europe/Berlin
+BEGIN:DAYLIGHT
+TZOFFSETFROM:+0100
+TZOFFSETTO:+0200
+TZNAME:CEST
+DTSTART:19700329T020000
+RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU
+END:DAYLIGHT
+BEGIN:STANDARD
+TZOFFSETFROM:+0200
+TZOFFSETTO:+0100
+TZNAME:CET
+DTSTART:19701025T030000
+RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU
+END:STANDARD
+END:VTIMEZONE
+BEGIN:VEVENT
+UID:1
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131006T231500Z
+RRULE:FREQ=MONTHLY
+EXDATE:20131006T231500Z
+SUMMARY:repeating by month
+END:VEVENT
+BEGIN:VEVENT
+UID:2
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART;TZID=Europe/Berlin:20131004T223930
+DTEND;TZID=Europe/Berlin:20131006T231500
+RRULE:FREQ=DAILY;COUNT=2
+SUMMARY:repeating by day\, twice
+END:VEVENT
+BEGIN:VEVENT
+UID:3
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131006T231500Z
+RRULE:FREQ=WEEKLY;INTERVAL=3;UNTIL=20140101T000000Z
+SUMMARY:repeating by 3 weeks\, until 2014
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_05.ics b/test/results/generate_05.ics
new file mode 100755
index 000000000..c1b17b980
--- /dev/null
+++ b/test/results/generate_05.ics
@@ -0,0 +1,12 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VEVENT
+UID:1
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930
+DTEND:20131006T231500
+SUMMARY:floating
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_06.ics b/test/results/generate_06.ics
new file mode 100755
index 000000000..580b65229
--- /dev/null
+++ b/test/results/generate_06.ics
@@ -0,0 +1,33 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+METHOD:PUBLISH
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART;VALUE=DATE:20131004
+X-MICROSOFT-CDO-ALLDAYEVENT:TRUE
+X-MICROSOFT-MSNCALENDAR-ALLDAYEVENT:TRUE
+SUMMARY:Sample Event
+ORGANIZER;CN="Sebastian Pekarek":mailto:mail@sebbo.net
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;DELEGATED-FROM="matt@examp
+ le.com";CN="John":MAILTO:john@example.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;PARTSTAT=DELEGATED;DELEGATED-TO="john@exampl
+ e.com";CN="Smith, Matt; (\"Sales\")":MAILTO:matt@example.com
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-PT10M
+REPEAT:2
+DURATION:PT1M
+DESCRIPTION:Sample Event
+END:VALARM
+BEGIN:VALARM
+ACTION:DISPLAY
+TRIGGER:-PT1H
+DESCRIPTION:I'm a reminder :)
+END:VALARM
+URL;VALUE=URI:http://sebbo.net/
+STATUS:CONFIRMED
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_07.ics b/test/results/generate_07.ics
new file mode 100755
index 000000000..8bcbf70be
--- /dev/null
+++ b/test/results/generate_07.ics
@@ -0,0 +1,30 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VEVENT
+UID:1
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131006T231500Z
+RRULE:FREQ=MONTHLY;BYMONTH=1,4,7,10
+SUMMARY:repeating by month
+END:VEVENT
+BEGIN:VEVENT
+UID:2
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+RRULE:FREQ=DAILY;COUNT=2;BYDAY=MO,WE,FR
+SUMMARY:repeating on Mo/We/Fr\, twice
+END:VEVENT
+BEGIN:VEVENT
+UID:3
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131006T231500Z
+RRULE:FREQ=DAILY;INTERVAL=1;BYMONTHDAY=1,15
+SUMMARY:repeating on 1st and 15th
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_08.ics b/test/results/generate_08.ics
new file mode 100755
index 000000000..5e73d7ab0
--- /dev/null
+++ b/test/results/generate_08.ics
@@ -0,0 +1,16 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131004T231500Z
+SUMMARY:Simple Event
+ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;PARTSTAT=NEEDS-ACTION;RSVP
+ =TRUE:MAILTO:mail@example.com
+CREATED:20131004T233453Z
+LAST-MODIFIED:20131004T233453Z
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/results/generate_09.ics b/test/results/generate_09.ics
new file mode 100755
index 000000000..f1adf168e
--- /dev/null
+++ b/test/results/generate_09.ics
@@ -0,0 +1,17 @@
+BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//sebbo.net//ical-generator.tests//EN
+METHOD:REQUEST
+BEGIN:VEVENT
+UID:123
+SEQUENCE:0
+DTSTAMP:20131004T233453Z
+DTSTART:20131004T223930Z
+DTEND:20131004T231500Z
+SUMMARY:Sample Event
+ORGANIZER;CN="Sebastian Pekarek";EMAIL=mail@sebbo.net:mailto:mail2@example
+ 2.com
+ATTENDEE;ROLE=REQ-PARTICIPANT;CUTYPE=INDIVIDUAL;PARTSTAT=NEEDS-ACTION;RSVP
+ =TRUE:MAILTO:mail@example.com
+END:VEVENT
+END:VCALENDAR
\ No newline at end of file
diff --git a/test/tools.ts b/test/tools.ts
new file mode 100644
index 000000000..aef8e43e9
--- /dev/null
+++ b/test/tools.ts
@@ -0,0 +1,370 @@
+'use strict';
+
+import assert from 'assert';
+import moment from 'moment';
+import momentTz from 'moment-timezone';
+import {DateTime} from 'luxon';
+import dayjs from 'dayjs';
+import dayJsUTCPlugin from 'dayjs/plugin/utc.js';
+import dayJsTimezonePlugin from 'dayjs/plugin/timezone.js';
+import {
+ checkDate,
+ escape,
+ foldLines,
+ formatDate,
+ formatDateTZ,
+ toDate,
+ toDurationString
+} from '../src/tools.js';
+
+dayjs.extend(dayJsUTCPlugin);
+dayjs.extend(dayJsTimezonePlugin);
+
+describe('ICalTools', function () {
+ describe('formatDate()', function () {
+ describe('Date / String', function () {
+ it('timezone=0 dateonly=0 floating=0', function () {
+ assert.strictEqual(
+ formatDate(null, '2018-07-05T18:24:00.052Z', false, false),
+ '20180705T182400Z'
+ );
+ });
+ it('timezone=0 dateonly=0 floating=1', function () {
+ assert.strictEqual(
+ formatDate(null, '2018-07-05T18:24:00.052Z', false, true),
+ '20180705T182400'
+ );
+ });
+ it('timezone=0 dateonly=1 floating=0', function () {
+ assert.strictEqual(
+ formatDate(null, '2018-07-05T18:24:00.052Z', true, false),
+ '20180705'
+ );
+ });
+ it('timezone=0 dateonly=1 floating=1', function () {
+ assert.strictEqual(
+ formatDate(null, '2018-07-05T18:24:00.052Z', true, true),
+ '20180705'
+ );
+ });
+ it('timezone=1 dateonly=0 floating=0', function () {
+ assert.strictEqual(
+ formatDate('Europe/Berlin', '2018-07-05T18:24:00.052', false, false),
+ '20180705T182400'
+ );
+ });
+ it('timezone=1 dateonly=0 floating=1', function () {
+ assert.strictEqual(
+ formatDate('Europe/Berlin', '2018-07-05T18:24:00.052', false, true),
+ '20180705T182400'
+ );
+ });
+ it('timezone=1 dateonly=1 floating=0', function () {
+ assert.strictEqual(
+ formatDate('Europe/Berlin', '2018-07-05T18:24:00.052', true, false),
+ '20180705'
+ );
+ });
+ it('timezone=1 dateonly=1 floating=1', function () {
+ assert.strictEqual(
+ formatDate('Europe/Berlin', '2018-07-05T18:24:00.052', true, true),
+ '20180705'
+ );
+ });
+ it('should work with / prefixed global timezones', function () {
+ assert.strictEqual(
+ formatDate('/Europe/Berlin', '2018-07-05T18:24:00.052', false, false),
+ '20180705T182400'
+ );
+ });
+ });
+ describe('moment.js', function () {
+ it('should work without setting a timezone', function () {
+ assert.strictEqual(
+ formatDate(null, moment('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T182400Z'
+ );
+ });
+ it('should work with timezone in event / calendar (with moment-timezone)', function () {
+ assert.strictEqual(
+ formatDate('Canada/Saskatchewan', moment('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T122400'
+ );
+ });
+ it('should work with floating flag', function () {
+ assert.strictEqual(
+ formatDate(null, moment('2018-07-05T18:24:00.052'), false, true),
+ '20180705T182400'
+ );
+ });
+ });
+ describe('moment-timezone.js', function () {
+ it('should work without setting a timezone', function () {
+ assert.strictEqual(
+ formatDate(null, momentTz('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T182400Z'
+ );
+ });
+ it('should work with timezone in event / calendar (with moment-timezone)', function () {
+ assert.strictEqual(
+ formatDate('Canada/Saskatchewan', momentTz('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T122400'
+ );
+ });
+ it('should work with floating flag', function () {
+ assert.strictEqual(
+ formatDate(null, momentTz('2018-07-05T18:24:00.052'), false, true),
+ '20180705T182400'
+ );
+ });
+ });
+ describe('Luxon', function () {
+ it('should work without setting a timezone', function () {
+ assert.strictEqual(
+ formatDate(null, DateTime.fromISO('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T182400Z'
+ );
+ });
+ it('should work with timezone in event / calendar (with moment-timezone)', function () {
+ assert.strictEqual(
+ formatDate('Canada/Saskatchewan', DateTime.fromISO('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T122400'
+ );
+ });
+ it('should work with floating flag', function () {
+ assert.strictEqual(
+ formatDate(null, DateTime.fromISO('2018-07-05T18:24:00.052'), false, true),
+ '20180705T182400'
+ );
+ });
+ it('should work with dateonly flag', function () {
+ assert.strictEqual(
+ formatDate(null, DateTime.fromISO('2018-07-05T18:24:00.052'), true, false),
+ '20180705'
+ );
+ });
+ it('should work with dateonly flag, non floating, and date with timezone', function () {
+ assert.strictEqual(
+ formatDate(null, DateTime.fromISO('2024-03-17T00:00:00.000+01:00', {setZone: true}), true),
+ '20240317'
+ );
+ });
+ });
+ describe('Day.js', function () {
+ it('should work without setting a timezone', function () {
+ assert.strictEqual(
+ formatDate(null, dayjs('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T182400Z'
+ );
+ });
+ it('should work with timezone in event / calendar (with moment-timezone)', function () {
+ assert.strictEqual(
+ formatDate('Canada/Saskatchewan', dayjs('2018-07-05T18:24:00.052Z'), false, false),
+ '20180705T122400'
+ );
+ });
+ it('should work with floating flag', function () {
+ assert.strictEqual(
+ formatDate(null, dayjs('2018-07-05T18:24:00.052'), false, true),
+ '20180705T182400'
+ );
+ });
+ it('should work with dateonly flag', function () {
+ assert.strictEqual(
+ formatDate(null, dayjs('2018-07-05T18:24:00.052'), true, false),
+ '20180705'
+ );
+ });
+ });
+ });
+
+ describe('formatDateTZ()', function () {
+ it('should work with timezone', function () {
+ const ed = {timezone: 'Europe/Berlin'};
+ assert.strictEqual(
+ formatDateTZ('Europe/Berlin', 'DSTART', moment('2018-07-02T15:48:05.000Z'), ed),
+ 'DSTART;TZID=Europe/Berlin:20180702T174805'
+ );
+ });
+ it('should work without timezone', function () {
+ assert.strictEqual(
+ formatDateTZ(null, 'DSTART', '2018-07-02T15:48:05.000Z', {}),
+ 'DSTART:20180702T154805Z'
+ );
+ });
+ it('should work without eventdata parameter', function () {
+ assert.strictEqual(
+ formatDateTZ(null, 'DSTART', '2018-07-02T15:48:05.000Z'),
+ 'DSTART:20180702T154805Z'
+ );
+ });
+ });
+
+ describe('escape()', function () {
+ it('should escape \\', function () {
+ assert.strictEqual(
+ escape('Lorem \\ipsum', false),
+ 'Lorem \\\\ipsum'
+ );
+ });
+ it('should escape ;', function () {
+ assert.strictEqual(
+ escape('Lorem ;ipsum', false),
+ 'Lorem \\;ipsum'
+ );
+ });
+ it('should escape ,', function () {
+ assert.strictEqual(
+ escape('Lorem, ipsum', false),
+ 'Lorem\\, ipsum'
+ );
+ });
+ it('should escape \\r', function () {
+ assert.strictEqual(
+ escape('Lorem \ripsum', false),
+ 'Lorem \\nipsum'
+ );
+ });
+ it('should escape \\n', function () {
+ assert.strictEqual(
+ escape('Lorem \nipsum', false),
+ 'Lorem \\nipsum'
+ );
+ });
+ it('should escape \\r\\n', function () {
+ assert.strictEqual(
+ escape('Lorem \r\nipsum', false),
+ 'Lorem \\nipsum'
+ );
+ });
+ it('should escape " in text when inQuotes = true', function () {
+ assert.strictEqual(
+ escape('Lorem "ipsum', true),
+ 'Lorem \\"ipsum'
+ );
+ });
+ it('should not escape " in text when inQuotes = false', function () {
+ assert.strictEqual(
+ escape('Lorem "ipsum', false),
+ 'Lorem "ipsum'
+ );
+ });
+ });
+
+ describe('foldLines()', function () {
+ it('should basically work correctly', function () {
+ assert.strictEqual(
+ foldLines('12345678ikjhgztrde546rf7g8hjiomkjnhgqfcdxerdftgzuinjhgcfvtzvzvuwcbiweciujzvguhbghbbqwxowidoi21e8981'),
+ '12345678ikjhgztrde546rf7g8hjiomkjnhgqfcdxerdftgzuinjhgcfvtzvzvuwcbiweciujz\r\n vguhbghbbqwxowidoi21e8981'
+ );
+ });
+ it('should not split surrogate pairs', function () {
+ assert.strictEqual(
+ foldLines('👋🏼12345678ikjhgztrde546rf7g8hjiomkjnhgqfcdxerdftgzuinjhgcfvtzvzvuwcbiweciujvguhbghbbqwxowidoi21e8981'),
+ '👋🏼12345678ikjhgztrde546rf7g8hjiomkjnhgqfcdxerdftgzuinjhgcfvtzvzvuwcb\r\n iweciujvguhbghbbqwxowidoi21e8981'
+ );
+ });
+ });
+
+ describe('checkDate()', function () {
+ describe('Date', function () {
+ it('should work with valid Date', function () {
+ const date = new Date();
+ assert.equal(checkDate(date, 'foo'), date);
+ });
+ it('should throw error for invalid Date', function () {
+ const date = new Date('foo');
+ assert.throws(() => {
+ checkDate(date, 'foo');
+ }, /`foo` has to be a valid date!/);
+ });
+ });
+ describe('String', function () {
+ it('should work with valid String', function () {
+ const date = '2021-03-28T13:15:23.587Z';
+ assert.equal(checkDate(date, 'foo'), date);
+ });
+ it('should throw error for invalid String', function () {
+ const date = 'foo';
+ assert.throws(() => {
+ checkDate(date, 'foo');
+ }, /`foo` has to be a valid date!/);
+ });
+ });
+ describe('Luxon', function () {
+ it('should work with valid Luxon', function () {
+ const date = DateTime.now();
+ assert.equal(checkDate(date, 'foo'), date);
+ });
+ it('should throw error for invalid Luxon', function () {
+ const date = DateTime.fromISO('foo');
+ assert.throws(() => {
+ checkDate(date, 'foo');
+ }, /`foo` has to be a valid date!/);
+ });
+ });
+ describe('Moment', function () {
+ it('should work with valid Moment', function () {
+ const date = moment();
+ assert.equal(checkDate(date, 'foo'), date);
+ });
+ it('should throw error for invalid Moment', function () {
+ const date = moment('foo', 'MM/DD/YYYY', true);
+ assert.throws(() => {
+ checkDate(date, 'foo');
+ }, /`foo` has to be a valid date!/);
+ });
+ });
+ describe('Day.js', function () {
+ it('should work with valid Day.js', function () {
+ const date = dayjs();
+ assert.equal(checkDate(date, 'foo'), date);
+ });
+ it('should throw error for invalid Day.js', function () {
+ const date = dayjs('foo');
+ assert.throws(() => {
+ checkDate(date, 'foo');
+ }, /`foo` has to be a valid date!/);
+ });
+ });
+ });
+
+ describe('toDate()', function () {
+ it('should work with strings', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(date.toJSON()), date);
+ });
+ it('should work with native Date', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(date), date);
+ });
+ it('should work with moment object', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(moment(date)), date);
+ });
+ it('should work with moment-timezone object', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(momentTz(date)), date);
+ });
+ it('should work with Day.js object', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(dayjs(date)), date);
+ });
+ it('should work with luxon DateTime object', function () {
+ const date = new Date();
+ assert.deepStrictEqual(toDate(DateTime.fromJSDate(date)), date);
+ });
+ });
+
+ describe('toDurationString()', function () {
+ it('should work', async function () {
+ assert.strictEqual(toDurationString(0), 'PT0S');
+ assert.strictEqual(toDurationString(1), 'PT1S');
+ assert.strictEqual(toDurationString(60), 'PT1M');
+ assert.strictEqual(toDurationString(3600), 'PT1H');
+ assert.strictEqual(toDurationString(86400), 'P1D');
+
+ assert.strictEqual(toDurationString(-3600), '-PT1H');
+ });
+ });
+});
diff --git a/test/types.ts b/test/types.ts
new file mode 100644
index 000000000..1571974e5
--- /dev/null
+++ b/test/types.ts
@@ -0,0 +1,54 @@
+/**
+ * Check if stubs are working
+ */
+
+import assert from 'assert';
+import dayjs from 'dayjs';
+import { DateTime } from 'luxon';
+import moment from 'moment';
+import momentTz from 'moment-timezone';
+import rrule from 'rrule';
+
+import {
+ ICalAttendeeData,
+ ICalAttendeeJSONData,
+ ICalCalendarData,
+ ICalCalendarJSONData,
+ ICalCategoryData,
+ ICalCategoryJSONData,
+ ICalDayJsStub,
+ ICalEventJSONData,
+ ICalLuxonDateTimeStub,
+ ICalMomentStub,
+ ICalMomentTimezoneStub,
+ ICalRRuleStub
+} from '../src/index.js';
+
+const dayJsTest = dayjs() satisfies ICalDayJsStub;
+const luxonTest = DateTime.now() satisfies ICalLuxonDateTimeStub;
+const momentTest = moment() satisfies ICalMomentStub;
+const momentTimezoneTest = momentTz() satisfies ICalMomentTimezoneStub;
+
+const RRule = rrule.RRule;
+const rruleTest = new RRule({ freq: RRule.WEEKLY, dtstart: new Date() }) satisfies ICalRRuleStub;
+
+const attendeeJson = {} as ICalAttendeeJSONData satisfies ICalAttendeeData;
+const calendarJson = {} as ICalCalendarJSONData satisfies ICalCalendarData;
+const categoryJson = {} as ICalCategoryJSONData satisfies ICalCategoryData;
+const eventJson = {} as ICalEventJSONData satisfies ICalEventJSONData;
+
+describe('ical-generator Types', function () {
+ it('stubs should be compatible with third party libraries', function () {
+ assert.ok(dayJsTest, 'day.js stub should be compatible');
+ assert.ok(luxonTest, 'luxon stub should be compatible');
+ assert.ok(momentTest, 'moment stub should be compatible');
+ assert.ok(momentTimezoneTest, 'moment-timezone stub should be compatible');
+ assert.ok(rruleTest, 'rrule stub should be compatible');
+ });
+ it('calendar data should be compatible with calendar json data', function () {
+ assert.ok(attendeeJson, 'attendee json data should be compatible');
+ assert.ok(calendarJson, 'calendar json data should be compatible');
+ assert.ok(categoryJson, 'category json data should be compatible');
+ assert.ok(eventJson, 'event json data should be compatible');
+ });
+});
diff --git a/tsup.config.ts b/tsup.config.ts
index 5343aa217..33e4d45aa 100644
--- a/tsup.config.ts
+++ b/tsup.config.ts
@@ -3,9 +3,7 @@ import { defineConfig } from 'tsup';
export default defineConfig({
clean: true,
entry: [
- 'src/lib/index.ts',
- 'src/bin/cli.ts',
- 'src/bin/start.ts'
+ 'src/index.ts'
],
format: ['esm', 'cjs'],
dts: true,
diff --git a/typedoc.json b/typedoc.json
index f8625ec49..af67f146f 100644
--- a/typedoc.json
+++ b/typedoc.json
@@ -1,11 +1,11 @@
{
- "entryPoints": ["./src/lib/index.ts"],
+ "entryPoints": ["./src/index.ts"],
"exclude": [],
"excludeInternal": true,
"excludePrivate": true,
"excludeProtected": true,
"includeVersion": true,
- "name": "",
+ "name": "ical-generator",
"out": "./docs/reference",
"plugin": [],
"readme": "README.md",
+
+
+ 
+
+
+ 
