TypeScript Logger.error方法代码示例

export function parser(exstr: string, all_excmds: any): any[] {
    // Expand aliases
    const expandedExstr = aliases.expandExstr(exstr)
    const [func, ...args] = expandedExstr.trim().split(/\s+/)

    // Try to find which namespace (ex, text, ...) the command is in
    const dotIndex = func.indexOf(".")
    const namespce = func.substring(0, dotIndex)
    const funcName = func.substring(dotIndex + 1)
    const excmds = all_excmds[namespce]

    if (excmds === undefined) {
        throw new Error(`Unknwown namespace: ${namespce}.`);
    }

    // Convert arguments, but only for ex commands
    let converted_args
    if (namespce == "") {
        let types
        try {
            types = (metadata
                .getFile("src/excmds.ts")
                .getFunction(funcName)
                .type as FunctionType)
                .args
        } catch (e) {
            throw `Could not find type information for excmd ${funcName}`
        }
        try {
            converted_args = convertArgs(types, args)
        } catch (e) {
            logger.error("Error executing or parsing:", exstr, e)
            throw e
        }
    } else {
        converted_args = args
    }

    if (excmds[funcName] === undefined) {
        logger.error("Not an excmd:", exstr)
        throw `Not an excmd: ${func}`
    }

    return [excmds[funcName], converted_args]
}

export async function getId(name: string): Promise<string> {
    try {
        const containers = await getAll()
        const res = containers.filter(
            c => c.name.toLowerCase() === name.toLowerCase(),
        )
        if (res.length !== 1) {
            throw new Error("")
        } else {
            return res[0].cookieStoreId
        }
    } catch (e) {
        logger.error(
            "[Container.getId] could not find a container with that name.",
        )
    }
}

export function registerEvListenerAction(
    elem: EventTarget,
    add: boolean,
    event: string,
) {
    // We're only interested in the subset of EventTargets that are Elements.
    if (!(elem instanceof Element)) {
        return
    }

    // Prevent bad elements from being processed
    //
    // This is defence in depth: we should never receive an invalid elem here
    // because add/removeEventListener currently throws a TypeError if the given
    // element is not a standard library EventTarget subclass.
    try {
        // Node prototype functions work on the C++ representation of the
        // Node, which a faked JS object won't have.
        // hasChildNodes() is chosen because it should be cheap.
        Node.prototype.hasChildNodes.apply(elem)
    } catch (e) {
        // Don't throw a real exception because addEventListener wouldn't and we
        // don't want to break content code.
        logger.error("Elem is not a real Node", elem)
        return
    }

    switch (event) {
        case "click":
        case "mousedown":
        case "mouseup":
        case "mouseover":
            if (add) {
                hintworthy_js_elems.push(elem)
            } else {
                // Possible bug: If a page adds an event listener for "click" and
                // "mousedown" and removes "mousedown" twice, we lose track of the
                // elem even though it still has a "click" listener.
                // Fixing this might not be worth the added complexity.
                const index = hintworthy_js_elems.indexOf(elem)
                if (index >= 0) hintworthy_js_elems.splice(index, 1)
            }
    }
}

async function updateVersion() {
    try {
        // If any monster any makes a novelty tag this will break.
        // So let's just ignore any errors.
        const parser = new RssParser()
        const feed = await parser.parseURL("https://github.com/tridactyl/tridactyl/tags.atom")
        const mostRecent = feed.items[0]

        // Update our last update check timestamp and the version itself.
        Config.set("update", "lastchecktime", Date.now())
        highestKnownVersion = {
            version: mostRecent.title,
            releaseDate: new Date(mostRecent.pubDate), // e.g. 2018-12-04T15:24:43.000Z
        }
        logger.debug("Checked for new version of Tridactyl, found ", highestKnownVersion)
    } catch (e) {
        logger.error("Error while checking for updates: ", e)
    }
}

export async function exists(cname: string): Promise<boolean> {
    let exists = false
    try {
        const containers = await getAll()
        const res = containers.filter(c => {
            return c.name.toLowerCase() === cname.toLowerCase()
        })
        if (res.length > 0) {
            exists = true
        }
    } catch (e) {
        exists = true // Make sure we don't accidentally break the constraint on query error.
        logger.error(
            "[Container.exists] Error querying contextualIdentities:",
            e,
        )
    }
    return exists
}

export async function theme(element) {
    // Remove any old theme
    for (const theme of THEMES.map(prefixTheme)) {
        element.classList.remove(theme)
    }
    if (insertedCSS) {
        // Typescript doesn't seem to be aware than remove/insertCSS's tabid
        // argument is optional
        await browserBg.tabs.removeCSS(await ownTabId(), customCss)
        insertedCSS = false
    }

    const newTheme = await config.getAsync("theme")

    // Add a class corresponding to config.get('theme')
    if (newTheme !== "default") {
        element.classList.add(prefixTheme(newTheme))
    }

    // Insert custom css if needed
    if (newTheme !== "default" && !THEMES.includes(newTheme)) {
        customCss.code = await config.getAsync("customthemes", newTheme)
        if (customCss.code) {
            await browserBg.tabs.insertCSS(await ownTabId(), customCss)
            insertedCSS = true
        } else {
            logger.error("Theme " + newTheme + " couldn't be found.")
        }
    }

    // Record for re-theming
    // considering only elements :root (page and cmdline_iframe)
    // TODO:
    //     - Find ways to check if element is already pushed
    if (
        THEMED_ELEMENTS.length < 2 &&
        element.tagName.toUpperCase() === "HTML"
    ) {
        THEMED_ELEMENTS.push(element)
    }
}