@tomgiee/tsdp 1.0.0

package/dist/src/utils/line-reader.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Line reading utilities for SDP (RFC 8866)
+ *
+ * RFC 8866 specifies CRLF as the standard line terminator, but parsers
+ * SHOULD accept LF alone for robustness. This module handles all three
+ * cases: CRLF, LF, and CR.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLines = splitLines;
+exports.parseLine = parseLine;
+exports.parseLines = parseLines;
+exports.joinLines = joinLines;
+exports.formatLine = formatLine;
+exports.isValidLineType = isValidLineType;
+exports.getLineTypeName = getLineTypeName;
+/**
+ * Split input text into lines, handling CRLF, LF, and CR
+ *
+ * RFC 8866 Section 5: Text fields use UTF-8 encoding, line ending is CRLF,
+ * but parsers SHOULD accept LF alone for compatibility.
+ *
+ * @param input - Raw SDP text
+ * @returns Array of lines (line endings removed)
+ */
+function splitLines(input) {
+    const lines = [];
+    let current = '';
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === '\r' && input[i + 1] === '\n') {
+            // CRLF (standard)
+            lines.push(current);
+            current = '';
+            i++; // Skip the \n
+        }
+        else if (ch === '\n') {
+            // LF alone (tolerant)
+            lines.push(current);
+            current = '';
+        }
+        else if (ch === '\r') {
+            // CR alone (tolerant, rare)
+            lines.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    // Add final line if input doesn't end with line terminator
+    if (current.length > 0) {
+        lines.push(current);
+    }
+    return lines;
+}
+/**
+ * Parse a single SDP line into type and value
+ *
+ * SDP line format: <type>=<value>
+ * where <type> is a single character
+ *
+ * @param line - Single SDP line
+ * @returns Parsed line with type and value, or null if invalid
+ */
+function parseLine(line) {
+    // Empty lines are ignored
+    if (line.length === 0) {
+        return null;
+    }
+    // Valid SDP lines must have at least "x=" (3 characters minimum)
+    if (line.length < 2) {
+        return null;
+    }
+    // Second character must be '='
+    if (line[1] !== '=') {
+        return null;
+    }
+    return {
+        type: line[0],
+        value: line.substring(2)
+    };
+}
+/**
+ * Parse all lines in SDP input into structured format
+ *
+ * @param input - Raw SDP text
+ * @returns Array of parsed lines (skips empty/invalid lines)
+ */
+function parseLines(input) {
+    const rawLines = splitLines(input);
+    const parsedLines = [];
+    for (let i = 0; i < rawLines.length; i++) {
+        const parsed = parseLine(rawLines[i]);
+        if (parsed !== null) {
+            parsedLines.push({
+                type: parsed.type,
+                value: parsed.value,
+                lineNumber: i + 1
+            });
+        }
+    }
+    return parsedLines;
+}
+/**
+ * Join lines back into SDP text format with CRLF line endings
+ *
+ * Always outputs standard CRLF line endings per RFC 8866,
+ * even if input used LF or CR.
+ *
+ * @param lines - Array of line strings (without line endings)
+ * @returns SDP text with CRLF line endings
+ */
+function joinLines(lines) {
+    return lines.join('\r\n') + '\r\n';
+}
+/**
+ * Format a line in SDP format: <type>=<value>
+ *
+ * @param type - Single character line type
+ * @param value - Line value
+ * @returns Formatted SDP line (without line ending)
+ */
+function formatLine(type, value) {
+    if (type.length !== 1) {
+        throw new Error(`Invalid line type '${type}': must be single character`);
+    }
+    return `${type}=${value}`;
+}
+/**
+ * Validate that a line type is a valid SDP field
+ *
+ * Valid SDP field types per RFC 8866:
+ * v, o, s, i, u, e, p, c, b, t, r, z, k, a, m
+ *
+ * @param type - Line type character
+ * @returns true if valid SDP field type
+ */
+function isValidLineType(type) {
+    const validTypes = ['v', 'o', 's', 'i', 'u', 'e', 'p', 'c', 'b', 't', 'r', 'z', 'k', 'a', 'm'];
+    return validTypes.includes(type);
+}
+/**
+ * Get display name for a line type
+ *
+ * @param type - Line type character
+ * @returns Human-readable field name
+ */
+function getLineTypeName(type) {
+    var _a;
+    const names = {
+        'v': 'version',
+        'o': 'origin',
+        's': 'session name',
+        'i': 'information',
+        'u': 'URI',
+        'e': 'email',
+        'p': 'phone',
+        'c': 'connection',
+        'b': 'bandwidth',
+        't': 'timing',
+        'r': 'repeat',
+        'z': 'timezone',
+        'k': 'key',
+        'a': 'attribute',
+        'm': 'media'
+    };
+    return (_a = names[type]) !== null && _a !== void 0 ? _a : 'unknown';
+}

package/dist/src/utils/time-converter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Time conversion utilities for SDP (RFC 8866)
+ *
+ * SDP uses typed time values with unit suffixes for repeat and timezone fields:
+ * - d: days
+ * - h: hours
+ * - m: minutes
+ * - (no suffix): seconds
+ */
+import { TypedTime } from '../types/primitives';
+/**
+ * Parse a typed time string into a TypedTime object
+ *
+ * Formats:
+ * - "7d" = 7 days
+ * - "3h" = 3 hours
+ * - "120m" = 120 minutes
+ * - "3600" = 3600 seconds (no suffix)
+ * - "30s" = 30 seconds (explicit suffix)
+ * - "-1h" = -1 hour (for timezone offsets)
+ *
+ * @param input - Time string to parse
+ * @returns TypedTime object
+ * @throws ParseError if input is invalid
+ */
+export declare function parseTypedTime(input: string): TypedTime;
+/**
+ * Serialize a TypedTime object to a string
+ *
+ * Outputs compact format per RFC 8866:
+ * - days: "7d"
+ * - hours: "3h"
+ * - minutes: "120m"
+ * - seconds: "3600" (no suffix for seconds)
+ *
+ * @param time - TypedTime to serialize
+ * @returns Formatted time string
+ */
+export declare function serializeTypedTime(time: TypedTime): string;
+/**
+ * Convert TypedTime to seconds
+ *
+ * Useful for comparisons and calculations
+ *
+ * @param time - TypedTime to convert
+ * @returns Number of seconds
+ */
+export declare function typedTimeToSeconds(time: TypedTime): number;
+/**
+ * Convert seconds to TypedTime with appropriate unit
+ *
+ * Chooses the largest unit that divides evenly:
+ * - 86400 seconds -> 1 day
+ * - 3600 seconds -> 1 hour
+ * - 120 seconds -> 2 minutes
+ * - 45 seconds -> 45 seconds
+ *
+ * @param seconds - Number of seconds
+ * @returns TypedTime with appropriate unit
+ */
+export declare function secondsToTypedTime(seconds: number): TypedTime;
+/**
+ * Add two TypedTime values
+ *
+ * Result uses the smaller unit to avoid precision loss
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns Sum of the two times
+ */
+export declare function addTypedTimes(a: TypedTime, b: TypedTime): TypedTime;
+/**
+ * Compare two TypedTime values
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns Negative if a < b, 0 if equal, positive if a > b
+ */
+export declare function compareTypedTimes(a: TypedTime, b: TypedTime): number;
+/**
+ * Check if two TypedTime values are equal
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns true if equal (same duration in seconds)
+ */
+export declare function typedTimesEqual(a: TypedTime, b: TypedTime): boolean;
+/**
+ * Normalize a TypedTime to use the most compact unit
+ *
+ * Examples:
+ * - {value: 120, unit: 'minutes'} -> {value: 2, unit: 'hours'}
+ * - {value: 3600, unit: 'seconds'} -> {value: 1, unit: 'hours'}
+ *
+ * @param time - TypedTime to normalize
+ * @returns Normalized TypedTime
+ */
+export declare function normalizeTypedTime(time: TypedTime): TypedTime;
+//# sourceMappingURL=time-converter.d.ts.map

package/dist/src/utils/time-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-converter.d.ts","sourceRoot":"","sources":["../../../src/utils/time-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAA6B,MAAM,qBAAqB,CAAC;AAG3E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAqCvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAiB1D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAc1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAmB7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAMnE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAEpE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAEnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAG7D"}

package/dist/src/utils/time-converter.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Time conversion utilities for SDP (RFC 8866)
+ *
+ * SDP uses typed time values with unit suffixes for repeat and timezone fields:
+ * - d: days
+ * - h: hours
+ * - m: minutes
+ * - (no suffix): seconds
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypedTime = parseTypedTime;
+exports.serializeTypedTime = serializeTypedTime;
+exports.typedTimeToSeconds = typedTimeToSeconds;
+exports.secondsToTypedTime = secondsToTypedTime;
+exports.addTypedTimes = addTypedTimes;
+exports.compareTypedTimes = compareTypedTimes;
+exports.typedTimesEqual = typedTimesEqual;
+exports.normalizeTypedTime = normalizeTypedTime;
+const primitives_1 = require("../types/primitives");
+const errors_1 = require("../types/errors");
+/**
+ * Parse a typed time string into a TypedTime object
+ *
+ * Formats:
+ * - "7d" = 7 days
+ * - "3h" = 3 hours
+ * - "120m" = 120 minutes
+ * - "3600" = 3600 seconds (no suffix)
+ * - "30s" = 30 seconds (explicit suffix)
+ * - "-1h" = -1 hour (for timezone offsets)
+ *
+ * @param input - Time string to parse
+ * @returns TypedTime object
+ * @throws ParseError if input is invalid
+ */
+function parseTypedTime(input) {
+    if (input.length === 0) {
+        throw new errors_1.ParseError('Empty time value', 0, 0);
+    }
+    // Match pattern: optional minus sign, digits, optional unit suffix
+    const match = input.match(/^(-?\d+)([dhms]?)$/);
+    if (!match) {
+        throw new errors_1.ParseError(`Invalid time format: '${input}'`, 0, 0);
+    }
+    const value = parseInt(match[1], 10);
+    const suffix = match[2] || 's'; // Default to seconds if no suffix
+    if (isNaN(value)) {
+        throw new errors_1.ParseError(`Invalid time value: '${value}'`, 0, 0);
+    }
+    // Map suffix to unit
+    const unit = (() => {
+        switch (suffix) {
+            case 'd':
+                return 'days';
+            case 'h':
+                return 'hours';
+            case 'm':
+                return 'minutes';
+            case 's':
+            case '':
+                return 'seconds';
+            default:
+                throw new errors_1.ParseError(`Invalid time unit: '${suffix}'`, 0, 0);
+        }
+    })();
+    return (0, primitives_1.createTypedTime)(value, unit);
+}
+/**
+ * Serialize a TypedTime object to a string
+ *
+ * Outputs compact format per RFC 8866:
+ * - days: "7d"
+ * - hours: "3h"
+ * - minutes: "120m"
+ * - seconds: "3600" (no suffix for seconds)
+ *
+ * @param time - TypedTime to serialize
+ * @returns Formatted time string
+ */
+function serializeTypedTime(time) {
+    const suffix = (() => {
+        switch (time.unit) {
+            case 'days':
+                return 'd';
+            case 'hours':
+                return 'h';
+            case 'minutes':
+                return 'm';
+            case 'seconds':
+                return ''; // No suffix for seconds
+            default:
+                throw new Error(`Invalid time unit: ${time.unit}`);
+        }
+    })();
+    return `${time.value}${suffix}`;
+}
+/**
+ * Convert TypedTime to seconds
+ *
+ * Useful for comparisons and calculations
+ *
+ * @param time - TypedTime to convert
+ * @returns Number of seconds
+ */
+function typedTimeToSeconds(time) {
+    const multipliers = {
+        'seconds': 1,
+        'minutes': 60,
+        'hours': 3600,
+        'days': 86400
+    };
+    const multiplier = multipliers[time.unit];
+    if (multiplier === undefined) {
+        throw new Error(`Invalid time unit: ${time.unit}`);
+    }
+    return time.value * multiplier;
+}
+/**
+ * Convert seconds to TypedTime with appropriate unit
+ *
+ * Chooses the largest unit that divides evenly:
+ * - 86400 seconds -> 1 day
+ * - 3600 seconds -> 1 hour
+ * - 120 seconds -> 2 minutes
+ * - 45 seconds -> 45 seconds
+ *
+ * @param seconds - Number of seconds
+ * @returns TypedTime with appropriate unit
+ */
+function secondsToTypedTime(seconds) {
+    if (seconds < 0) {
+        throw new Error('Time cannot be negative');
+    }
+    // Try each unit from largest to smallest
+    if (seconds % 86400 === 0) {
+        return (0, primitives_1.createTypedTime)(seconds / 86400, 'days');
+    }
+    if (seconds % 3600 === 0) {
+        return (0, primitives_1.createTypedTime)(seconds / 3600, 'hours');
+    }
+    if (seconds % 60 === 0) {
+        return (0, primitives_1.createTypedTime)(seconds / 60, 'minutes');
+    }
+    return (0, primitives_1.createTypedTime)(seconds, 'seconds');
+}
+/**
+ * Add two TypedTime values
+ *
+ * Result uses the smaller unit to avoid precision loss
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns Sum of the two times
+ */
+function addTypedTimes(a, b) {
+    const aSeconds = typedTimeToSeconds(a);
+    const bSeconds = typedTimeToSeconds(b);
+    const totalSeconds = aSeconds + bSeconds;
+    return secondsToTypedTime(totalSeconds);
+}
+/**
+ * Compare two TypedTime values
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns Negative if a < b, 0 if equal, positive if a > b
+ */
+function compareTypedTimes(a, b) {
+    return typedTimeToSeconds(a) - typedTimeToSeconds(b);
+}
+/**
+ * Check if two TypedTime values are equal
+ *
+ * @param a - First time value
+ * @param b - Second time value
+ * @returns true if equal (same duration in seconds)
+ */
+function typedTimesEqual(a, b) {
+    return typedTimeToSeconds(a) === typedTimeToSeconds(b);
+}
+/**
+ * Normalize a TypedTime to use the most compact unit
+ *
+ * Examples:
+ * - {value: 120, unit: 'minutes'} -> {value: 2, unit: 'hours'}
+ * - {value: 3600, unit: 'seconds'} -> {value: 1, unit: 'hours'}
+ *
+ * @param time - TypedTime to normalize
+ * @returns Normalized TypedTime
+ */
+function normalizeTypedTime(time) {
+    const seconds = typedTimeToSeconds(time);
+    return secondsToTypedTime(seconds);
+}

package/dist/src/validator/media-validator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Media validators for SDP (RFC 8866)
+ *
+ * Validates media descriptions and media-level constraints per RFC 8866.
+ */
+import { MediaDescription } from '../types/media';
+import { ValidationResult } from './session-validator';
+/**
+ * Validate a media description
+ *
+ * Checks RFC 8866 Section 5.14 (m=) and media-level field requirements.
+ *
+ * @param media - Media description to validate
+ * @param index - Index of media description (for error messages)
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+export declare function validateMediaDescription(media: MediaDescription, index: number, hasSessionConnection: boolean): ValidationResult;
+/**
+ * Validate all media descriptions in a session
+ *
+ * @param mediaDescriptions - Array of media descriptions
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+export declare function validateAllMediaDescriptions(mediaDescriptions: readonly MediaDescription[], hasSessionConnection: boolean): ValidationResult;
+//# sourceMappingURL=media-validator.d.ts.map

package/dist/src/validator/media-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/media-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAA8B,MAAM,qBAAqB,CAAC;AAOnF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,MAAM,EACb,oBAAoB,EAAE,OAAO,GAC5B,gBAAgB,CAyBlB;AAuVD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,EAC9C,oBAAoB,EAAE,OAAO,GAC5B,gBAAgB,CASlB"}