1 files changed, 192 insertions, 0 deletions
diff --git a/static/ts/jcal.ts b/static/ts/jcal.ts
new file mode 100644
index 00000000..41f33db4
--- /dev/null
+++ b/static/ts/jcal.ts
@@ -0,0 +1,192 @@
+export { jcal_to_xcal }
+
+import { xcal, ical_type, JCalProperty, JCal } from './types'
+import { asList } from './lib'
+
+function jcal_type_to_xcal(doc: Document, type: ical_type, value: any): Element {
+    let el = doc.createElementNS(xcal, type);
+    switch (type) {
+        case 'boolean':
+            el.textContent = value ? "true" : "false";
+            break;
+
+        case 'float':
+        case 'integer':
+            el.textContent = '' + value;
+            break;
+
+        case 'period':
+            let [start, end] = value;
+            let startEl = doc.createElementNS(xcal, 'start');
+            startEl.textContent = start;
+            let endEl: Element;
+            if (end.find('P')) {
+                endEl = doc.createElementNS(xcal, 'duration');
+            } else {
+                endEl = doc.createElementNS(xcal, 'end');
+            }
+            endEl.textContent = end;
+            el.appendChild(startEl);
+            el.appendChild(endEl);
+            break;
+
+        case 'recur':
+            for (var key in value) {
+                if (!value.hasOwnProperty(key)) continue;
+                if (key === 'byday') {
+                    for (let v of value[key]) {
+                        let e = doc.createElementNS(xcal, key);
+                        e.textContent = v;
+                        el.appendChild(e);
+                    }
+                } else {
+                    let e = doc.createElementNS(xcal, key);
+                    e.textContent = value[key];
+                    el.appendChild(e);
+                }
+            }
+            break;
+
+        case 'date':
+        // case 'time':
+        case 'date-time':
+
+        case 'duration':
+
+        case 'binary':
+        case 'text':
+        case 'uri':
+        case 'cal-address':
+        case 'utc-offset':
+            el.textContent = value;
+            break;
+
+        default:
+        /* TODO error */
+    }
+    return el;
+}
+
+function jcal_property_to_xcal_property(
+    doc: Document,
+    jcal: JCalProperty
+): Element {
+    let [propertyName, params, type, ...values] = jcal;
+
+    let tag = doc.createElementNS(xcal, propertyName);
+
+    /* setup parameters */
+    let paramEl = doc.createElementNS(xcal, 'params');
+    for (var key in params) {
+        /* Check if the key actually belongs to us.
+           At least (my) format also appears when iterating
+           over the parameters. Probably a case of builtins
+           vs user defined.
+
+           This is also the reason we can't check if params
+           is empty beforehand, and instead check the
+           number of children of paramEl below.
+        */
+        if (!params.hasOwnProperty(key)) continue;
+
+        let el = doc.createElementNS(xcal, key);
+
+        for (let v of asList(params.get(key))) {
+            let text = doc.createElementNS(xcal, 'text');
+            text.textContent = '' + v;
+            el.appendChild(text);
+        }
+
+        paramEl.appendChild(el);
+    }
+
+    if (paramEl.childElementCount > 0) {
+        tag.appendChild(paramEl);
+    }
+
+    /* setup value (and type) */
+    // let typeEl = doc.createElementNS(xcal, type);
+
+    switch (propertyName) {
+        case 'geo':
+            if (type == 'float') {
+                // assert values[0] == [x, y]
+                let [x, y] = values[0];
+                let lat = doc.createElementNS(xcal, 'latitude')
+                let lon = doc.createElementNS(xcal, 'longitude')
+                lat.textContent = x;
+                lon.textContent = y;
+                tag.appendChild(lat);
+                tag.appendChild(lon);
+            } else {
+                /* TODO, error */
+            }
+            break;
+        /* TODO reenable this
+    case 'request-status':
+        if (type == 'text') {
+            // assert values[0] instanceof Array
+            let [code, desc, ...data] = values[0];
+            let codeEl = doc.createElementNS(xcal, 'code')
+            code.textContent = code;
+            tag.appendChild(codeEl);
+
+
+            let descEl = doc.createElementNS(xcal, 'description')
+            desc.textContent = desc;
+            tag.appendChild(descEl);
+
+            if (data !== []) {
+                data = data[0];
+                let dataEl = doc.createElementNS(xcal, 'data')
+                data.textContent = data;
+                tag.appendChild(dataEl);
+            }
+        } else {
+            /* TODO, error * /
+        }
+        break;
+        */
+        default:
+            for (let value of values) {
+                tag.appendChild(jcal_type_to_xcal(doc, type, value))
+            }
+    }
+
+    return tag;
+}
+
+
+function jcal_to_xcal(...jcals: JCal[]): Document {
+    let doc = document.implementation.createDocument(xcal, 'icalendar');
+    for (let jcal of jcals) {
+        doc.documentElement.appendChild(jcal_to_xcal_inner(doc, jcal));
+    }
+    return doc;
+}
+
+function jcal_to_xcal_inner(doc: Document, jcal: JCal) {
+    let [tagname, properties, components] = jcal;
+
+    let xcal_tag = doc.createElementNS(xcal, tagname);
+
+    /* I'm not sure if the properties and components tag should be left out
+       when empty. It should however NOT be an error to leave them in.
+    */
+
+    let xcal_properties = doc.createElementNS(xcal, 'properties');
+    for (let property of properties) {
+        xcal_properties.appendChild(jcal_property_to_xcal_property(doc, property));
+    }
+
+    let xcal_children = doc.createElementNS(xcal, 'components');
+    for (let child of components) {
+        xcal_children.appendChild(jcal_to_xcal_inner(doc, child));
+    }
+
+    xcal_tag.appendChild(xcal_properties);
+    xcal_tag.appendChild(xcal_children);
+
+    return xcal_tag;
+
+}