iamcal 3.0.3 → 4.0.0

package/src/parse.ts

@@ -1,5 +1,4 @@
 import readline from 'readline'
-import { Readable } from 'stream'
 import { Component } from './component'
 import { Calendar, CalendarEvent } from './components'
 import {
@@ -23,10 +22,22 @@ export class DeserializationError extends Error {
  * @param lines The serialized component as a **readline** interface.
  * @returns The deserialized calendar component object.
  * @throws {DeserializationError} If the component is invalid.
+ * @deprecated Use the synchronous `deserializeComponentLines` instead.
  */
 export async function deserializeComponent(
     lines: readline.Interface
 ): Promise<Component> {
+    const realLines = await readLines(lines)
+    return deserializeComponentLines(realLines)
+}
+
+/**
+ * Deserialize a calendar component from a list of lines.
+ * @param lines The serialized component as a list of lines.
+ * @returns The deserialized calendar component object.
+ * @throws {DeserializationError} If the component is invalid.
+ */
+export function deserializeComponentLines(lines: string[]): Component {
     const component = new Component('')
     let done = false
 
@@ -35,7 +46,7 @@ export async function deserializeComponent(
 
     const subcomponentLines = new Array<string>()
 
-    const processLine = async (line: string) => {
+    const processLine = (line: string) => {
         if (line.trim() === '') return
 
         if (done) {
@@ -71,7 +82,7 @@ export async function deserializeComponent(
             // Check the length of the stack after being popped
             if (stack.length == 1) {
                 subcomponentLines.push(line)
-                const subcomponent = await deserializeComponentString(
+                const subcomponent = deserializeComponentString(
                     subcomponentLines.join('\r\n')
                 )
                 subcomponentLines.length = 0
@@ -117,14 +128,14 @@ export async function deserializeComponent(
         that exists on a long line.
     */
     let unfoldedLine = ''
-    for await (const line of lines) {
+    for (const line of lines) {
         if (line.startsWith(' ') || line.startsWith('\t')) {
             // Unfold continuation line (remove leading whitespace and append)
             unfoldedLine += line.replace(/[\r\n]/, '').slice(1)
         } else {
             if (unfoldedLine) {
                 // Process the previous unfolded line
-                await processLine(unfoldedLine)
+                processLine(unfoldedLine)
             }
             // Start a new unfolded line
             unfoldedLine = line
@@ -132,7 +143,7 @@ export async function deserializeComponent(
     }
 
     // Process the last unfolded line
-    await processLine(unfoldedLine)
+    processLine(unfoldedLine)
 
     // Check that component has been closed
     if (!done) {
@@ -142,21 +153,34 @@ export async function deserializeComponent(
     return component
 }
 
+/**
+ * Convert a **readline** interface to a list of lines.
+ * @param rl The interface.
+ * @returns The list of lines read from the interface.
+ * @throws {DeserializationError} If the component is invalid.
+ */
+async function readLines(rl: readline.Interface): Promise<string[]> {
+    return new Promise(resolve => {
+        const lines: string[] = []
+
+        rl.on('line', line => {
+            lines.push(line)
+        })
+        rl.on('close', () => {
+            resolve(lines)
+        })
+    })
+}
+
 /**
  * Deserialize a calendar component string.
  * @param text The serialized component.
  * @returns The deserialized component object.
  * @throws {DeserializationError} If the component is invalid.
  */
-export async function deserializeComponentString(
-    text: string
-): Promise<Component> {
-    const stream = Readable.from(text)
-    const lines = readline.createInterface({
-        input: stream,
-        crlfDelay: Infinity,
-    })
-    return deserializeComponent(lines)
+export function deserializeComponentString(text: string): Component {
+    const lines = text.split(/\r?\n/g)
+    return deserializeComponentLines(lines)
 }
 
 /**
@@ -164,8 +188,8 @@ export async function deserializeComponentString(
  * @param text A serialized calendar as you would see in an iCalendar file.
  * @returns The parsed calendar object.
  */
-export async function parseCalendar(text: string): Promise<Calendar> {
-    const component = await deserializeComponentString(text)
+export function parseCalendar(text: string): Calendar {
+    const component = deserializeComponentString(text)
     return new Calendar(component)
 }
 
@@ -174,8 +198,8 @@ export async function parseCalendar(text: string): Promise<Calendar> {
  * @param text A serialized event as you would see in an iCalendar file.
  * @returns The parsed event object.
  */
-export async function parseEvent(text: string): Promise<CalendarEvent> {
-    const component = await deserializeComponentString(text)
+export function parseEvent(text: string): CalendarEvent {
+    const component = deserializeComponentString(text)
     return new CalendarEvent(component)
 }
 

package/src/property/Property.ts

@@ -1,4 +1,5 @@
-import { CalendarDateOrTime } from 'src/date'
+import { CalendarDateOrTime, CalendarDate, CalendarDateTime, isCalendarDateOrTime } from '../date'
+import { CalendarDuration } from '../duration'
 import {
     escapePropertyParameterValue,
     escapeTextPropertyValue,
@@ -16,7 +17,7 @@ import {
     RsvpExpectation,
 } from './parameter'
 import { validateCalendarUserAddress, validateContentType } from './validate'
-import { AllowedValueType, getDefaultValueType } from './valueType'
+import { AllowedValueType, KnownValueType, getDefaultValueType } from './valueType'
 
 /**
  * Represents a property of a calendar component as described by RFC 5545 in
@@ -55,13 +56,72 @@ export class Property {
     }
 
     static fromDate(name: string, value: CalendarDateOrTime): Property {
+        const valueType = value.isFullDay() ? 'DATE' : 'DATE-TIME'
+        let properties: { [k: string]: string | string[] } | undefined = undefined
+        if (getDefaultValueType(name) !== valueType) {
+            properties = { VALUE: valueType }
+        }
+
+        return new Property(
+            name,
+            value.getValue(),
+            properties,
+        )
+    }
+
+    static fromDuration(name: string, value: CalendarDuration): Property {
         return new Property(
             name,
             value.getValue(),
-            value.isFullDay() ? { VALUE: 'DATE' } : undefined
+            { VALUE: 'CALENDARDATE' },
         )
     }
 
+    /**
+     * Get the value of this property, converted into the appropriate class if possible.
+     * @returns The value as a string or appropriate class.
+     */
+    getValue(): string | CalendarDateOrTime | CalendarDuration {
+        const valueType = this.getValueType()
+        switch (valueType) {
+            case 'DATE':
+                return new CalendarDate(this.value)
+            case 'DATE-TIME':
+                return new CalendarDateTime(this.value)
+            case 'DURATION':
+                return new CalendarDuration(this.value)
+            default:
+                return this.value
+        }
+    }
+
+    /**
+     * Set the value of this property and change the value type if a class is used.
+     * @param value The new value as a string or class.
+     */
+    setValue(value: string | CalendarDateOrTime | CalendarDuration) {
+        const valueTypeBefore = this.getExplicitValueType()
+        if (typeof value === 'string') {
+            // Set string
+            this.value = value
+        } else if (isCalendarDateOrTime(value)) {
+            // Set date
+            this.value = value.getValue()
+            this.setValueType(value.isFullDay() ? 'DATE' : 'DATE-TIME')
+        } else {
+            // Set duration
+            this.value = value.getValue()
+            this.setValueType('DURATION')
+        }
+
+        // Remove value type if set to default, unless it was already set
+        const valueType = this.getExplicitValueType()
+        const defaultValueType = this.getDefaultValueType()
+        if (valueType === defaultValueType && valueType !== valueTypeBefore) {
+            this.removeValueType()
+        }
+    }
+
     setParameter(name: string, value: string | string[]) {
         this._parameters.set(
             name.toUpperCase(),
@@ -148,8 +208,23 @@ export class Property {
      * @returns The value type of this property.
      */
     getValueType(): AllowedValueType {
-        const assignedValueType = this.getParameter('VALUE')?.[0].toUpperCase()
-        return assignedValueType ?? getDefaultValueType(this.name)
+        return this.getExplicitValueType() ?? this.getDefaultValueType()
+    }
+
+    /**
+     * Get the value type of this property.
+     * @returns The value type of this property, or `undefined` if unset.
+     */
+    getExplicitValueType(): AllowedValueType | undefined {
+        return this.getParameter('VALUE')?.[0].toUpperCase()
+    }
+
+    /**
+     * Get the default value type for this property.
+     * @returns The default value type based on the name of this property.
+     */
+    getDefaultValueType(): KnownValueType {
+        return getDefaultValueType(this.name)
     }
 
     /**

package/src/property/validate.ts

@@ -85,7 +85,7 @@ export function validateDateTime(value: string) {
         parseDateTimeString(value)
     } catch {
         throw new PropertyValidationError(
-            `${value} does not match pattern for DATETIME`
+            `${value} does not match pattern for DATE-TIME`
         )
     }
 }