Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/sleitnick/rbxts-beacon
Beacon is a signal implementation for sending and receiving events
https://github.com/sleitnick/rbxts-beacon
roblox-ts
Last synced: 2 months ago
JSON representation
Beacon is a signal implementation for sending and receiving events
- Host: GitHub
- URL: https://github.com/sleitnick/rbxts-beacon
- Owner: Sleitnick
- License: mit
- Created: 2022-05-03T20:49:29.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2023-05-08T13:44:27.000Z (over 1 year ago)
- Last Synced: 2024-09-23T22:48:28.772Z (3 months ago)
- Topics: roblox-ts
- Language: TypeScript
- Homepage: https://www.npmjs.com/package/@rbxts/beacon
- Size: 114 KB
- Stars: 2
- Watchers: 1
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# Beacon
Beacon is a signal implementation for sending and receiving events.
## Signal API
### Types
```ts
type SignalParams = Parameters<
T extends unknown[] ? (...args: T) => never : T extends unknown ? (arg: T) => never : () => never
>;
type SignalCallback = (...args: SignalParams) => unknown;
type SignalWait = T extends unknown[] ? LuaTuple : T;
```
### Constructor
```ts
const signal = new Signal();
```
### `Signal.Connect`
```ts
public Connect(callback: SignalCallback): Connection
```
Connects a callback, which will be called each time the signal is fired. The returned connection can be disconnected to stop receiving events.
### `Signal.Once`
```ts
public Once(callback: SignalCallback): Connection
```
Same as `Signal.Connect`, but disconnects itself after the first time it is triggered.
### `Signal.Fire`
```ts
public Fire(...args: SignalParams): void
```
Fires the signal with the given event. All connected callbacks will receive the event. Internally, this uses `task.spawn` to fire each callback.
### `Signal.FireDeferred`
```ts
public FireDeferred(...args: SignalParams): void
```
Same as `Signal.Fire`, except uses `task.defer` internally.
### `Signal.Wait`
```ts
public Wait(): SignalWait
```
Yields the calling thread until the signal is next fired. Returns the fired event.
### `Signal.DisconnectAll`
```ts
public DisconnectAll(): void
```
Disconnects all connections on the signal.
### `Signal.Destroy`
```ts
public Destroy(): void
```
Alias for `Signal.DisconnectAll`.
## Connection API
### `Connection.Connected`
```ts
public Connected: boolean
```
Indicates if the connection is currently connected.
### `Connection.Disconnect`
```ts
public Disconnect(): void
```
Disconnects the connection.
### `Connection.Destroy`
```ts
public Destroy(): void
```
Alias for `Connection.Disconnect`.
## Example
```ts
const messenger = new Signal();
const connection = messenger.Connect((msg) => {
print(`Got message: ${msg}`);
});
messenger.Fire("Hello world!");
connection.Disconnect();
messenger.Fire("No one will see this");
// The spawned thread will wait indefinitely until the
// signal is fired. If all connections are disconnected
// using signal.Destroy() or signal.DisconnectAll(), then
// the waiting thread will be closed.
task.spawn(() => {
const msg = messenger.Wait();
print(`Got message from waiting: ${msg}`);
});
task.wait(2);
messenger.Fire("Hello to the waiting thread");
// Destroying isn't necessary for cleanup, but is nice when
// using signals in OOP environments for quick cleanup.
messenger.Destroy();
```
### Different number of arguments
```ts
// No args:
const signal = new Signal();
signal.Connect(() => {});
signal.Fire();
// One arg:
const signal = new Signal();
signal.Connect((n) => print(n));
signal.Fire(32);
// One arg, named (preferred over the above):
const signal = new Signal<[points: number]>();
signal.Connect((points) => print(points));
signal.Fire(64);
// Multiple args:
const signal = new Signal<[msg: string, value: number, cool: boolean]>();
signal.Connect((msg, value, cool) => print(msg, cool, value));
signal.Fire("hello", 10, true);
```