@zambiethebully/signals/dist/index.js

Roblox like signal library for Minecraft scripting or whatever else JS/TS related

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  Signal: () => Signal
});
module.exports = __toCommonJS(src_exports);

// src/Signals.ts
var SignalConnection = class {
  #disconnectCallback;
  connected = true;
  constructor(disconnectCallback) {
    this.#disconnectCallback = disconnectCallback;
  }
  disconnect() {
    if (!this.connected)
      return;
    try {
      this.#disconnectCallback();
      this.connected = false;
    } catch (err) {
      console.warn(err);
    }
  }
};
var Signal = class _Signal {
  static #global = new _Signal();
  #callbacks = {};
  fire(event, ...args) {
    const callbackArray = this.#callbacks[event];
    if (!callbackArray)
      return;
    for (const callback of callbackArray) {
      if (callback === void 0)
        continue;
      try {
        callback(...args);
      } catch (err) {
        console.warn(err);
      }
    }
  }
  connect(event, callback) {
    let callbackArray = this.#callbacks[event];
    if (!callbackArray)
      callbackArray = [];
    const disconnectFn = () => {
      const index = this.#callbacks[event].indexOf(callback);
      delete this.#callbacks[event][index];
    };
    callbackArray.push(callback);
    this.#callbacks[event] = callbackArray;
    return new SignalConnection(disconnectFn);
  }
  once(event, callback) {
    const connection = this.connect(event, function(...args) {
      try {
        callback(args);
      } catch (err) {
        console.warn(err);
      }
      connection.disconnect();
    });
    return connection;
  }
  async wait(event) {
    const self = this;
    return await new Promise((resolve, reject) => {
      self.once(event, resolve);
    });
  }
  static fire(event, ...args) {
    this.#global.fire(event, ...args);
  }
  static connect(event, callback) {
    return this.#global.connect(event, callback);
  }
  static once(event, callback) {
    return this.#global.once(event, callback);
  }
  static async wait(event) {
    return this.#global.wait(event);
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Signal
});