Как мне предотвратить событие, пока код не будет выполнен через импорт/экспорт?

Получил решение. Добавление функций ожидания в логический флаг работает.

class Async {
    constructor(elem) {
        this.elem = document.querySelectorAll(elem)
        this.flag = true;
        this.selector(this.elem, 'click');
    }
    selector(node, eventName) {
        node.forEach(item => {
            item.addEventListener(eventName, (e) => this.group(e))
        })
    }
    waiting() {
        return new Promise(resolve => {
            setTimeout(() => {
                resolve(console.info('waiting . . .'))
            }, 1000)
        })
    }
    result() {
        console.info('test');
        this.flag = true;
    }
    async group(e) {
        // console.info(this.flag);
        if (this.flag) {
            this.flag = false;
            console.info('test');
            const a = await this.waiting();
            const b = await this.result();
        }

    }
}
const async = new Async('.button');

Объяснение

Вообще говоря

• Шаблон async/await был представлен в ES2017 JavaScript и является синтаксическим сахаром для более старых промисов.
• Некоторые старые браузеры не поддерживают async/await
• async — это новый способ сказать return Promise((resolve) => { ... }).
• await является аналогом async и более новым способом сказать .then(result => { ... }).
  • await можно использовать только в функциях, помеченных как async
• try/catch является аналогом .catch(error => { ... }). На самом деле это не ново, но вы можете использовать его в этом контексте.

Вы можете узнать больше о async/awaitздесь

Код

Я внес небольшие изменения в ваш код, чтобы он имел больше смысла и написал несколько комментариев, чтобы вы понимали все, что здесь происходит.

class Async {
    constructor(elem) {
        this.elem = document.querySelectorAll(elem)
        this.isRunning = false; // <-- Rename the flag variable to something more meaningful
        this.selector(this.elem, 'click');
    }
    selector(node, eventName) {
        node.forEach(item => {
            item.addEventListener(eventName, (e) => this.group(e))
        })
    }
    waiting() {
        return new Promise((resolve, reject) => { // <-- Move the Promise to here so that every codepath returns something
            if (!this.isRunning) {
                this.isRunning = true;
                console.info('Waiting ... '); // <-- Move the waiting before the timeout, because inside it is not actually waiting, its rather done

                setTimeout(() => { // <-- setTimeout runs the provided function after the provided time in milliseconds elapsed
                    this.isRunning = false; // <-- Switch the isRunning after the timeout, because that makes more sense (because now it is not running anymore)
                    resolve('Done'); // <-- Change the text to done and actually resolve it (eg. remove the console.info)
                }, 2000)
            } else {
                reject('There is already a button function running'); // <-- reject is like throwing an error
            }
        })
    }
    result() {
        console.info('test');
    }
    async group(e) {
        try {
            const a = await this.waiting(); // <-- Assigns 'Done' to the variable a
            console.info(a); // <-- prints the message

            this.result(); // <-- prints 'test' immidiatly after the above console.info
        } catch (error) {
            console.info(error); // <-- Prints the reject message in case the button is already running
        }

        /* group could also be written with the old syntax like this:

        this.waiting().then(result => {
            console.info(result); // Will print "Done" after 2000 milliseconds

            this.result(); // Will print test instantly after the above console.info(). You dont need to await it, because it is not an async function
        }).catch(error => {
            console.info(error); // Will print the reject message in case the button is already running
        });

        */
    }
}
const asyncButton = new Async('.button'); // <-- Don't use async as a variable name. It's a reserved keyword

Пример запуска

Это снова тот же код, но без комментариев, так что вы можете протестировать его прямо здесь, на StackOverflow.

class Async {
    constructor(elem) {
        this.elem = document.querySelectorAll(elem)
        this.isRunning = false;
        this.selector(this.elem, 'click');
    }
    selector(node, eventName) {
        node.forEach(item => {
            item.addEventListener(eventName, (e) => this.group(e))
        })
    }
    waiting() {
        return new Promise((resolve, reject) => { 
            if (!this.isRunning) {
                this.isRunning = true;
                console.info('Waiting ... '); 
                
                setTimeout(() => { 
                    this.isRunning = false;
                    resolve('Done');
                }, 2000)
            } else {
                reject('There is already a button function running'); 
            }
        })
    }
    result() {
        console.info('test');
    }
    async group(e) {
        try {
          const a = await this.waiting(); 
          console.info(a); 
          this.result();
        } catch(error) {
          console.info(error);
        }
    }
}
const asyncButton = new Async('.button');

<button class = "button">Test</button>