tag checker exercise

tagChecker.ts

import { assertNever } from 'assert-never'

const VALID_OUTPUT = 'Correctly tagged paragraph'

enum TAG_TYPE {
    OPENING,
    CLOSING
}

const tagParser = (tag: string) => {
    if (tag.startsWith('</')) {
        const value = tag.charAt(2)
        return { type: TAG_TYPE.CLOSING, value }
    }
    if (tag.startsWith('<')) {
        const value = tag.charAt(1)
        return { type: TAG_TYPE.OPENING, value }
    }
    throw Error('Invalid Tag Input')
}

const basicTagChecker = (input: string) => {
    const tags = input.match(/<([A-Z]|\/[A-Z])>/g)
    if (tags == null) return VALID_OUTPUT

    const stack: string[] = []
    let error
    tags.some((tag) => {
        const parsedTag = tagParser(tag)
        const { type, value } = parsedTag

        switch (type) {
            case TAG_TYPE.OPENING:
                stack.push(value)
                break
            case TAG_TYPE.CLOSING:
                const lastOpenedTag = stack.pop()
                if (lastOpenedTag == null) {
                    error = `Expected # found </${value}>`
                    return true
                }
                if (value !== lastOpenedTag) {
                    error = `Expected </${lastOpenedTag}> found </${value}>`
                    return true
                }
                break
            default:
                assertNever(type)
                break
        }
    })
    if (error != null) return error
    if (stack.length === 0) return VALID_OUTPUT

    const lastTag = stack.pop()
    return `Expected </${lastTag}> found #`
}

export { basicTagChecker }