Initial functional commit.

There seems to be a problem with my `Promise.any` polyfill library that needs fixing.

Author: T99

ts/main.ts

@@ -12,4 +12,35 @@
  * @since v0.1.0
  */
 
-// export { ClassName } from "./class-location";
+export { Semaphore } from "./semaphore";
+export { SemaphoreLock } from "./semaphore-lock";
+
+// @ts-ignore
+import { Semaphore } from "./semaphore";
+// @ts-ignore
+import { SemaphoreLock } from "./semaphore-lock";
+
+export async function main(): Promise<void> {
+
+let semaphore: Semaphore = new Semaphore(3);
+
+let count: number = 0;
+let locks: SemaphoreLock[] = [];
+
+for (let i: number = 0; i < 5; i++) {
+
+let lock: SemaphoreLock = await semaphore.getLock();
+
+locks.push(lock);
+console.log(`Got lock #${++count} (id: '${lock.getID()}')`);
+
+}
+
+console.log(`For loop finished...`);
+
+console.log(`Relinquishing lock #1...`);
+locks[0].relinquish();
+
+}
+
+main().catch((e: any) => console.error(e));

ts/semaphore-lock.ts

@@ -0,0 +1,45 @@
+/*
+ * Created by Trevor Sears <trevor@trevorsears.com> (https://trevorsears.com/).
+ * 3:09 PM -- September 09, 2021.
+ * Project: @jsdsl/semaphore
+ */
+
+export class SemaphoreLock {
+
+protected readonly id: string;
+
+protected relinquishmentPromise: Promise<string>;
+
+protected relinquisherFunction!: () => void;
+
+public constructor(id: string) {
+
+this.id = id;
+
+this.relinquishmentPromise = new Promise<string>((resolve: (id: string) => void): void => {
+
+this.relinquisherFunction = (): void => resolve(this.id);
+
+});
+
+}
+
+public getID(): string {
+
+return this.id;
+
+}
+
+public relinquish(): void {
+
+this.relinquisherFunction();
+
+}
+
+public onRelinquish(): Promise<string> {
+
+return this.relinquishmentPromise;
+
+}
+
+}

ts/semaphore.ts

@@ -0,0 +1,72 @@
+/*
+ * Created by Trevor Sears <trevor@trevorsears.com> (https://trevorsears.com/).
+ * 3:09 PM -- September 09, 2021.
+ * Project: @jsdsl/semaphore
+ */
+
+import "promise-any-polyfill";
+import crypto from "crypto";
+import { SemaphoreLock } from "./semaphore-lock";
+
+type OutstandingLockMap = {
+
+[id: string]: Promise<string>
+
+}
+
+export class Semaphore {
+
+protected readonly maxLockCount: number;
+
+protected outstandingLocks: OutstandingLockMap;
+
+public constructor(maxLockCount: number) {
+
+this.maxLockCount = maxLockCount;
+this.outstandingLocks = {};
+
+}
+
+public async getLock(): Promise<SemaphoreLock> {
+
+// While we are at or (hopefully not) above capacity...
+while (this.getLockCount() >= this.getMaximumLockCount()) {
+
+console.log(`Waiting to remove promise...`);
+
+let resolution: any = await Promise.any(Object.values(this.outstandingLocks))
+
+console.log(`resolution: ${resolution}`);
+
+// Remove the first resolved promise that we find.
+delete this.outstandingLocks[resolution];
+
+console.log(`...found promise to remove!`);
+
+}
+
+console.log(`Generating new lock.`);
+
+let id: string = crypto.randomBytes(16).toString("hex");
+
+let lock: SemaphoreLock = new SemaphoreLock(id);
+
+this.outstandingLocks[id] = lock.onRelinquish();
+
+return lock;
+
+}
+
+public getLockCount(): number {
+
+return Object.keys(this.outstandingLocks).length;
+
+}
+
+public getMaximumLockCount(): number {
+
+return this.maxLockCount;
+
+}
+
+}