fn display(&self) -> String {

    fn badge(&self) -> String {

        let display_annotations = cx.string(

        let badge_annotations = cx.string(

                .map(|i| i.display())

                .map(|i| i.badge())

        annotations.set(&mut cx, "display", display_annotations)?;

        annotations.set(&mut cx, "badge", badge_annotations)?;

        let untracked = cx.boolean(false);
        annotations.set(&mut cx, "untracked", untracked)?;
        // TODO: properly implement colours
        let color = cx.undefined();
        annotations.set(&mut cx, "color", color)?;

import { commands, ExtensionContext, Uri, window, workspace, scm, SourceControl, RelativePattern, SourceControlResourceGroup } from 'vscode';
import path from 'path';

import { commands, ExtensionContext, Uri, window, workspace, scm, SourceControl, RelativePattern, SourceControlResourceGroup, FileDecorationProvider, CancellationToken, Event, FileDecoration, ProviderResult, EventEmitter } from 'vscode';
import { join } from 'path';
import fs from 'fs';

function update_view(repository: string, path: string) {
    decoration_provider.emitDecorationEvent(Uri.file(path));

function update_resource(repository: string, resource: { path: string, display: string, tooltip: string, untracked: boolean }) {
    const repo = source_control_views.get(repository)!;
    let resource_states = resource.untracked ? repo.resource_groups[1].resourceStates : repo.resource_groups[0].resourceStates;
    let to_replace = resource_states.find((value, _index) => {
        value.resourceUri === Uri.file(resource.path)
    });

    const diffs = shortDiff(path);
    const resource_groups = source_control_views.get(repository)?.resource_groups!;
    let modified = [];
    let untracked = [];

    const new_resource = {
        resourceUri: Uri.file(path.join(repository, resource.path)),
        decorations: {
            tooltip: resource.tooltip,

    // Add all the fresh diffs first
    for (let diff of diffs) {
        const to_add = {
            resourceUri: Uri.file(join(repository, diff.path)),
            decorations: {
                tooltip: diff.tooltip,
            }
        }
        console.log(`Resource URI: ${to_add.resourceUri}`);
        if (diff.untracked) {
            untracked.push(to_add);
        } else {
            modified.push(to_add);

    }
    if (to_replace === undefined) {
        // Does not exst as resource in group
        source_control_views.get(repository)!.resource_groups[0].resourceStates = [new_resource];
    } else {
        to_replace = new_resource;

    resource_groups[0].resourceStates = modified;
    resource_groups[1].resourceStates = untracked;

}
class DecorationProvider implements FileDecorationProvider {
    private readonly onDidFileDecorationsEmitter = new EventEmitter<Uri | Uri[] | undefined>();
    get onDidChangeFileDecorations() {
        return this.onDidFileDecorationsEmitter.event;
    }
    emitDecorationEvent(uri: Uri | Uri[]) {
        this.onDidFileDecorationsEmitter.fire(uri);
    }
    provideFileDecoration(uri: Uri, token: CancellationToken): ProviderResult<FileDecoration> {
        console.log(`Decorating file: ${uri.fsPath}`);
        if (fs.lstatSync(uri.fsPath).isDirectory()) {
            return;
        } else {
            const diffs = shortDiff(uri.fsPath);
            console.assert(diffs.length <= 1);
            if (diffs.length == 1) {
                const diff = diffs[0];
                return {
                    badge: diff.badge,
                    tooltip: diff.tooltip,
                    propagate: true, // TODO: no propogation for deletions
                    color: diff.color,
                };
            } else {
                return new FileDecoration('', '');
            }
        }
    }

let decoration_provider = new DecorationProvider;

    const repositories = resolveRepositories(paths_to_resolve());

    window.registerFileDecorationProvider(decoration_provider);

    const repositories = resolveRepositories(paths_to_resolve());

        const repo_scm = scm.createSourceControl(scm_id, scm_label, Uri.file(repo_path));

            const repo_scm = scm.createSourceControl(scm_id, scm_label, Uri.file(repo_path));

                repo_scm.createResourceGroup('unrecorded', 'Unrecorded changes'),

                repo_scm.createResourceGroup('modified', 'Modified'),

                try {
                    const repository = findClosestRoot(Array.from(source_control_views.keys()), event.fsPath);
                    if (!ignored(repository, event.fsPath)) {
                        console.log(`Responding to change event on file ${event.fsPath} with parent ${repository}`);
                        const diffs = shortDiff(event.fsPath);
                        console.assert(diffs.length <= 1);
                        // // TODO: check if file is tracked
                        if (diffs.length === 1) {
                            // File has changed, update diff in explorer tree
                            update_resource(repository, diffs[0]);
                        } else {
                            // File has no diff, clear any diff in explorer tree
                        }
                    } else {
                        console.log(`Ignored change event from ${event.fsPath}`);
                    }
                } catch (e) {
                    console.error(e);

                const repository = findClosestRoot(Array.from(source_control_views.keys()), event.fsPath);
                if (!ignored(repository, event.fsPath)) {
                    console.log(`Responding to change event (repository: ${repo_path}) on file: ${event.fsPath}`);
                    update_view(repository, event.fsPath);
                } else {
                    console.log(`Ignored change event from ${event.fsPath}`);

        console.log(`Updating source control view for repository: ${repo_path}`);
        update_view(repo_path, repo_path);