tridactyl/src/msgsafe.ts

/** Messaging-safe copies of objects. Drops non-primitive properties.
 *
 *  Objects to be passed by messaging API must only comprise of the following,
 *  otherwise they're silently dropped. The silent drop is probably a bug. If
 *  you include a Symbol() you get a DataCloneError.
 *
 *   - string
 *   - number
 *   - boolean
 *   - null
 *   - undefined
 *   - objects containing attributes only of the above types
 *
 *  Could just copy all primitive attributes, but then we don't get the
 *  interface... If we have to do this again, consider generating automatically
 *  from typescript/lib/lib.dom.d.ts
 *
 * */

const messageSafeTypes = new Set([
    "string",
    "number",
    "boolean",
    "null",
    "undefined",
])

function pick(o, ...props) {
    return Object.assign({}, ...props.map(prop => ({ [prop]: o[prop] })))
}

/** Messaging-safe, one level copy of obj
 *
 *  Doesn't work for special objects like Events: Object.keys() is too
 *  parsimonious.
 *
 */
export function generic(obj): any {
    let ret = {}
    for (let key of Object.keys(obj)) {
        if (messageSafeTypes.has(typeof obj[key])) {
            ret[key] = obj[key]
        }
    }
    return ret
}

/** Messaging-safe, one level copy of obj
 *
 *  Also looks at prototype properties. Works for e.g. Event.
 *
 */
export function generic_all_props(obj): any {
    let ret = {}
    for (let key in obj) {
        if (messageSafeTypes.has(typeof obj[key])) {
            ret[key] = obj[key]
        }
    }
    return ret
}

export interface MsgSafeKeyboardEvent {
    // KeyboardEvent
    readonly altKey: boolean
    readonly shiftKey: boolean
    readonly metaKey: boolean
    readonly ctrlKey: boolean
    readonly repeat: boolean
    readonly isComposing: boolean

    readonly key: string
    readonly code: string
    readonly location: number
    readonly locale: string

    // Event
    readonly bubbles: boolean
    readonly cancelable: boolean
    readonly composed: boolean
    readonly defaultPrevented: boolean
    readonly eventPhase: number

    readonly timeStamp: string
    readonly type: string
    readonly isTrusted: boolean

    readonly target: MsgSafeNode
}

/** MsgSafe copy of keyevent. */
export function KeyboardEvent(ke): MsgSafeKeyboardEvent {
    let copy = pick(
        ke,
        "shiftKey",
        "metaKey",
        "altKey",
        "ctrlKey",
        "repeat",
        "key",
        "bubbles",
        "composed",
        "defaultPrevented",
        "eventPhase",
        "timeStamp",
        "type",
        "isTrusted",
    )
    copy.target = Node(ke.target)

    // Works but adds > 200 properties.
    // let copy = generic_all_props(ke)
    // copy.target = generic_all_props(ke.target)

    return copy
}

export interface MsgSafeNode {
    // w3 Node interface
    readonly nodeName: string
    readonly nodeValue: string
    readonly nodeType: number
    readonly namespaceURI: string
    readonly prefix?: string
    readonly localName: string
    readonly baseURI: string
    readonly textContent: string

    // w3 Element interface
    readonly tagName?: string

    // InputElement
    readonly type?: string

    // WAI-ARIA
    readonly role?: string

    // unknown spec
    readonly contentEditable?: string
    readonly isContentEditable?: boolean
    readonly disabled?: boolean
    readonly readonly?: boolean
}

export function Node(node: HTMLElement): MsgSafeNode {
    return pick(
        node,
        // w3 Node interface
        "nodeName",
        "nodeValue",
        "nodeType",
        "namespaceURI",
        "prefix",
        "localName",
        "baseURI",
        "textContent",

        // w3 Element interface
        "tagName",

        // InputElement
        "type",

        // WAI-ARIA
        "role",

        // unknown spec
        "contentEditable",
        "isContentEditable",
        "disabled",
        "readonly",
    )
}