xmpkit 0.1.3

Pure Rust implementation of Adobe XMP Toolkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! WebAssembly bindings for XMP date/time utilities

use crate::utils::datetime::XmpDateTime as RustXmpDateTime;
use crate::wasm::error::{xmp_error_to_wasm_error, XmpError};
use wasm_bindgen::prelude::*;

/// XMP Date/Time structure
///
/// Represents a date/time value with optional components.
/// XMP supports partial dates (e.g., just year, or year-month).
#[wasm_bindgen]
#[derive(Clone, Default)]
pub struct XmpDateTime {
    pub(crate) inner: RustXmpDateTime,
}

#[wasm_bindgen]
impl XmpDateTime {
    /// Create a new empty XMP date/time
    #[wasm_bindgen(constructor)]
    pub fn new() -> XmpDateTime {
        XmpDateTime::default()
    }

    /// Parse an XMP date/time string
    ///
    /// XMP date/time format:
    /// - `YYYY` - year only
    /// - `YYYY-MM` - year and month
    /// - `YYYY-MM-DD` - date only
    /// - `YYYY-MM-DDThh:mm:ss` - date and time
    /// - `YYYY-MM-DDThh:mm:ss.sss` - with fractional seconds
    /// - `YYYY-MM-DDThh:mm:ssZ` - UTC timezone
    /// - `YYYY-MM-DDThh:mm:ss+hh:mm` - timezone offset
    ///
    /// # Example
    ///
    /// ```javascript
    /// import { XmpDateTime } from './pkg/xmpkit.js';
    /// const dt = XmpDateTime.parse("2023-12-25T10:30:00Z");
    /// console.log(dt.year); // 2023
    /// ```
    pub fn parse(s: &str) -> Result<XmpDateTime, XmpError> {
        RustXmpDateTime::parse(s)
            .map(|dt| XmpDateTime { inner: dt })
            .map_err(xmp_error_to_wasm_error)
    }

    /// Format as XMP date/time string
    pub fn format(&self) -> String {
        self.inner.format()
    }

    /// Get the year
    #[wasm_bindgen(getter)]
    pub fn year(&self) -> i32 {
        self.inner.year
    }

    /// Get the month (1-12, 0 means not set)
    #[wasm_bindgen(getter)]
    pub fn month(&self) -> u8 {
        self.inner.month
    }

    /// Get the day (1-31, 0 means not set)
    #[wasm_bindgen(getter)]
    pub fn day(&self) -> u8 {
        self.inner.day
    }

    /// Get the hour (0-23)
    #[wasm_bindgen(getter)]
    pub fn hour(&self) -> u8 {
        self.inner.hour
    }

    /// Get the minute (0-59)
    #[wasm_bindgen(getter)]
    pub fn minute(&self) -> u8 {
        self.inner.minute
    }

    /// Get the second (0-59)
    #[wasm_bindgen(getter)]
    pub fn second(&self) -> u8 {
        self.inner.second
    }

    /// Get the nanoseconds (0-999999999)
    #[wasm_bindgen(getter)]
    pub fn nanosecond(&self) -> u32 {
        self.inner.nanosecond
    }

    /// Whether date components are present
    #[wasm_bindgen(getter)]
    pub fn has_date(&self) -> bool {
        self.inner.has_date
    }

    /// Whether time components are present
    #[wasm_bindgen(getter)]
    pub fn has_time(&self) -> bool {
        self.inner.has_time
    }

    /// Whether timezone is present
    #[wasm_bindgen(getter)]
    pub fn has_timezone(&self) -> bool {
        self.inner.has_timezone
    }

    /// Timezone sign: -1 (west), 0 (UTC), +1 (east)
    #[wasm_bindgen(getter)]
    pub fn tz_sign(&self) -> i8 {
        self.inner.tz_sign
    }

    /// Timezone hour offset (0-23)
    #[wasm_bindgen(getter)]
    pub fn tz_hour(&self) -> u8 {
        self.inner.tz_hour
    }

    /// Timezone minute offset (0-59)
    #[wasm_bindgen(getter)]
    pub fn tz_minute(&self) -> u8 {
        self.inner.tz_minute
    }
}