iamcal 2.1.2 → 3.0.1

package/src/parse.ts

@@ -2,6 +2,16 @@ import readline from 'readline'
 import { Readable } from 'stream'
 import { Component } from './component'
 import { Calendar, CalendarEvent } from './components'
+import {
+    isNameChar,
+    isParameterValueChar,
+    isPropertyValueChar,
+} from './patterns'
+import { Property } from './property/Property'
+import {
+    unescapePropertyParameterValue,
+    unescapeTextPropertyValue,
+} from './property/escape'
 
 /** Represents an error that occurs when deserializing a calendar component. */
 export class DeserializationError extends Error {
@@ -83,22 +93,7 @@ export async function deserializeComponent(
                 subcomponentLines.push(line)
             } else {
                 // Property
-                const colon = line.indexOf(':')
-                if (colon === -1) {
-                    throw new DeserializationError(
-                        `Invalid content line: ${line}`
-                    )
-                }
-                const name = line.slice(0, colon)
-                const value = line.slice(colon + 1)
-
-                const params = name.split(';')
-                const property = {
-                    name: params[0],
-                    params: params.slice(1),
-                    value: value,
-                }
-
+                const property = deserializeProperty(line)
                 component.properties.push(property)
             }
         }
@@ -147,19 +142,6 @@ export async function deserializeComponent(
     return component
 }
 
-/**
- * Deserialize a calendar component.
- * @param lines The serialized component as a **readline** interface.
- * @returns The deserialized calendar component object.
- * @throws {DeserializationError} If the component is invalid.
- * @deprecated Use {@link deserializeComponent} instead.
- */
-export async function deserialize(
-    lines: readline.Interface
-): Promise<Component> {
-    return deserializeComponent(lines)
-}
-
 /**
  * Deserialize a calendar component string.
  * @param text The serialized component.
@@ -177,17 +159,6 @@ export async function deserializeComponentString(
     return deserializeComponent(lines)
 }
 
-/**
- * Deserialize a calendar component string.
- * @param text The serialized component.
- * @returns The deserialized component object.
- * @throws {DeserializationError} If the component is invalid.
- * @deprecated Use {@link deserializeComponentString} instead.
- */
-export async function deserializeString(text: string): Promise<Component> {
-    return deserializeComponentString(text)
-}
-
 /**
  * Parse a serialized calendar.
  * @param text A serialized calendar as you would see in an iCalendar file.
@@ -207,3 +178,204 @@ export async function parseEvent(text: string): Promise<CalendarEvent> {
     const component = await deserializeComponentString(text)
     return new CalendarEvent(component)
 }
+
+/**
+ * Deserialize a component property.
+ * @param line The serialized content line that defines this property.
+ * @param strict If newlines are allowed to be LF and CRLF, not just CRLF. Defaults to false.
+ * @returns The deserialized property.
+ * @throws {DeserializationError} If content line is invalid.
+ */
+export function deserializeProperty(
+    line: string,
+    strict: boolean = false
+): Property {
+    // A stack to store characters before joining to a string
+    const stack = new Array<string>(line.length)
+    let stackPos = 0
+
+    /**
+     * Get the string currently contained in {@link stack} and reset the stack.
+     * @returns The string of characters below {@link stackPos} in {@link stack}.
+     */
+    function gatherStack(): string {
+        const s = stack.slice(0, stackPos).join('')
+        stackPos = 0
+        return s
+    }
+
+    let propertyName: string | undefined = undefined
+    const rawParameters: Map<string, string[]> = new Map()
+
+    let currentParam: string | undefined = undefined
+    let quoted: boolean = false
+    let hasQuote: boolean = false
+    enum Step {
+        Name,
+        ParamName,
+        ParamValue,
+        Value,
+    }
+    let step: Step = Step.Name
+
+    for (const char of line) {
+        // Handle folded content lines
+        const last = stack[stackPos - 1]
+        if (last === '\r') {
+            if (char !== '\n')
+                throw new DeserializationError('Invalid CR in content line.')
+
+            stack[stackPos++] = char
+            continue
+        } else if (char === '\n')
+            if (strict) {
+                throw new DeserializationError('Invalid LF in content line.')
+            } else {
+                stack[stackPos++] = char
+                continue
+            }
+
+        if (last === '\n') {
+            if (char !== ' ' && char !== '\t')
+                throw new DeserializationError('Invalid CRLF in content line.')
+
+            // Valid folded line sequence, remove (CR)LF
+            if (stack[stackPos - 2] === '\r') {
+                stackPos -= 2
+            } else {
+                stackPos -= 1
+            }
+            continue
+        }
+
+        if (char === '\r') {
+            stack[stackPos++] = char
+            continue
+        }
+
+        // Process character
+        if (step === Step.Name) {
+            // Continue parsing name
+            if (isNameChar(char)) {
+                stack[stackPos++] = char
+            } else if (char === ';') {
+                // End of name, begin parameters
+                propertyName = gatherStack()
+                stackPos = 0
+                step = Step.ParamName
+            } else if (char === ':') {
+                // End of name, begin value
+                propertyName = gatherStack()
+                stackPos = 0
+                step = Step.Value
+            } else {
+                throw new DeserializationError(
+                    `Invalid character "${char}" in content line name.`
+                )
+            }
+        } else if (step === Step.ParamName) {
+            // Continue parsing parameter name
+            if (isNameChar(char)) {
+                stack[stackPos++] = char
+            } else if (char === '=') {
+                // End of parameter name, begin parameter value
+                if (stackPos === 0)
+                    throw new DeserializationError(
+                        'Parameter name cannot be empty.'
+                    )
+
+                currentParam = gatherStack()
+                if (!rawParameters.has(currentParam)) {
+                    rawParameters.set(currentParam, [])
+                }
+                step = Step.ParamValue
+            } else {
+                throw new DeserializationError(
+                    `Invalid character "${char}" in parameter name.`
+                )
+            }
+        } else if (step === Step.ParamValue) {
+            // Continue parsing parameter value
+            if (char === '"') {
+                if (quoted) {
+                    quoted = false
+                } else {
+                    if (stackPos !== 0)
+                        throw new DeserializationError(
+                            'Invalid characters before quote in parameter value.'
+                        )
+
+                    quoted = true
+                    hasQuote = true
+                }
+            } else if (isParameterValueChar(char, quoted)) {
+                if (!quoted && hasQuote)
+                    if (stackPos !== 0)
+                        throw new DeserializationError(
+                            'Invalid characters after quote in parameter value.'
+                        )
+
+                stack[stackPos++] = char
+            } else if (char === ',') {
+                // End of parameter value, begin next parameter value
+                if (currentParam === undefined)
+                    throw new DeserializationError(
+                        'Invalid state, parameter name is undefined.'
+                    )
+                const paramValue = gatherStack()
+                rawParameters.get(currentParam)!.push(paramValue)
+                hasQuote = false
+                step = Step.ParamValue
+            } else if (char === ';') {
+                // End of parameter value, begin next parameter name
+                if (currentParam === undefined)
+                    throw new DeserializationError(
+                        'Invalid state, parameter name is undefined.'
+                    )
+                const paramValue = gatherStack()
+                rawParameters.get(currentParam)!.push(paramValue)
+                step = Step.ParamName
+            } else if (char === ':') {
+                // End of parameter value, begin value
+                if (currentParam === undefined)
+                    throw new DeserializationError(
+                        'Invalid state, parameter name is undefined.'
+                    )
+                const paramValue = gatherStack()
+                rawParameters.get(currentParam)!.push(paramValue)
+                step = Step.Value
+            }
+        } else if (step === Step.Value) {
+            // Continue parsing value
+            if (isPropertyValueChar(char)) {
+                stack[stackPos++] = char
+            } else if (char === '\r' || char === '\n') {
+                stack[stackPos++] = char
+            }
+        } else {
+            throw new DeserializationError('Parser got lost, step is invalid.')
+        }
+    }
+
+    // Final checks
+    if (quoted)
+        throw new DeserializationError(
+            'Unterminated quote in content line value.'
+        )
+    if (!propertyName) {
+        throw new DeserializationError(`Invalid content line, invalid format.`)
+    }
+
+    // The content line value is whatever is left in the stack
+    const rawValue: string = gatherStack()
+
+    // Parse parameters and value
+    const parsedParameters: { [k: string]: string[] } = {}
+    for (const [key, values] of rawParameters) {
+        const parsedValues = values.map(unescapePropertyParameterValue)
+        parsedParameters[key] = parsedValues
+    }
+    const parsedValue = unescapeTextPropertyValue(rawValue)
+
+    return new Property(propertyName, parsedValue, parsedParameters)
+}

package/src/patterns.ts

@@ -57,6 +57,12 @@ export const valueTypeText = new RegExp(
 export const valueTypeTime = /[0-9]{6}Z?/
 export const valueTypeUtcOffset = /[+-]([0-9]{2}){2,3}/
 
+// Content type as defined by RFC 4288 4.2
+export const regName = /[a-zA-Z0-9!#$&.+^_-]{1,127}/
+export const contentType = new RegExp(
+    '(' + regName.source + ')/(' + regName.source + ')'
+)
+
 /**
  * Check if a string matches a pattern for the whole string.
  * @param pattern The RegExp pattern to match against.
@@ -67,3 +73,61 @@ export function matchesWholeString(pattern: RegExp, text: string): boolean {
     const match = text.match(pattern)
     return match !== null && match[0] === text
 }
+
+/**
+ * Get the ordinal (character code) of a character.
+ * @param char The character to get the ordinal value of.
+ * @returns The ordinal as a number.
+ * @throws If the input string is empty.
+ */
+export function ord(char: string): number {
+    if (char.length === 0)
+        throw new Error('Expected a character, got empty string')
+
+    return char.charCodeAt(0)
+}
+
+/**
+ * Check if a character is allowed in a property or parameter name.
+ * @param char The character to check.
+ * @returns Whether or not the character is allowed.
+ */
+export function isNameChar(char: string): boolean {
+    return (
+        (ord(char) >= ord('A') && ord(char) <= ord('Z')) ||
+        (ord(char) >= ord('a') && ord(char) <= ord('z')) ||
+        (ord(char) >= ord('0') && ord(char) <= ord('9')) ||
+        char === '-'
+    )
+}
+
+/**
+ * Check if a character is allowwed in a property value.
+ * @param char The character to check.
+ * @returns Whether or not the character is allowed.
+ */
+export function isPropertyValueChar(char: string): boolean {
+    return ord(char) === 9 || ord(char) >= 32
+}
+
+/**
+ * Check if a character is allowwed in a parameter value.
+ * @param char The character to check.
+ * @param quoted Whether or not the parameter value is quoted, this allows ';', ':' and ','.
+ * @returns Whether or not the character is allowed.
+ */
+export function isParameterValueChar(
+    char: string,
+    quoted: boolean = false
+): boolean {
+    return (
+        // Allow HTAB
+        ord(char) === 9 ||
+        // Do not allow DQUOTE
+        (char !== '"' &&
+            // Allow non-control characters
+            ord(char) >= 32 &&
+            // These characters are only allowed if quoted
+            (quoted || !(char === ';' || char === ':' || char === ',')))
+    )
+}