Sample of functions in converting nested objects into flatten object array

nested-to-flat.ts

interface NestedKeyValuePair {
    key: string,
    value: string,
    next: NestedKeyValuePair
}

interface KeyValuePair {
    key: string,
    value: string
}

function flatten(input: NestedKeyValuePair) : KeyValuePair[] {
    // clone the input
    const original = {...input}
    
    let output = []
    var current = original

    while (current != undefined) {
        output.push({ key: current.key, value: current.value })
        
        current = current.next
    }

    return output
}

function toNestedKeyValuePair(input: KeyValuePair[]) : NestedKeyValuePair {
    // clone the input
    const original = input.map(obj => obj)

    let inputLength = original.length
    var parent = {} as NestedKeyValuePair

    original.reverse().forEach((obj, index) => {
        let current = parent

        current.key = obj.key
        current.value = obj.value

        let hasParent = inputLength > index + 1
        if (hasParent) {
            parent = { next: current } as NestedKeyValuePair
        }
    })

    return parent
}

// the testing object
const tests = {
    key: 'a', 
    value: 'valuea',
    next: {
        key: 'b', 
        value: 'valueb',
        next: {
            key: 'c', 
            value: 'valuec'
        }
    }
} as NestedKeyValuePair

// flatten the testing object
let flatTests = flatten(tests)

// try reverting back the flatten object into the original one
let backToOriginal = toNestedKeyValuePair(flatTests)

console.log(`Original object: ${JSON.stringify(tests)}`)
console.log(`Flattened object: ${JSON.stringify(flatTests)}`)
console.log(`Reverted back: ${JSON.stringify(backToOriginal)}`)