@lowerdeck/programmable-promise 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,11 @@
+
+$ microbundle
+Build "@lowerdeck/programmable-promise" to dist:
+        482 B: index.cjs.gz
+        417 B: index.cjs.br
+        173 B: index.modern.js.gz
+        148 B: index.modern.js.br
+        487 B: index.module.js.gz
+        418 B: index.module.js.br
+        555 B: index.umd.js.gz
+        480 B: index.umd.js.br

package/.turbo/turbo-test.log

@@ -0,0 +1,24 @@
+
+$ vitest run --passWithNoTests
+[?25l
+ RUN  v3.2.4 /Users/tobias/code/metorial/metorial-enterprise/oss/src/packages/shared/programmable-promise
+
+[?2026h
+ ❯ src/index.test.ts [queued]
+
+ Test Files 0 passed (1)
+      Tests 0 passed (0)
+   Start at 10:23:27
+   Duration 101ms
+[?2026l ✓ src/index.test.ts (4 tests) 3ms
+   ✓ ProgrammablePromise > should resolve with the provided value 1ms
+   ✓ ProgrammablePromise > should reject with the provided reason 1ms
+   ✓ ProgrammablePromise > should allow accessing the resolved value after resolution 0ms
+   ✓ ProgrammablePromise > should not have a value before resolution 0ms
+
+ Test Files  1 passed (1)
+      Tests  4 passed (4)
+   Start at  10:23:27
+   Duration  217ms (transform 29ms, setup 0ms, collect 28ms, tests 3ms, environment 0ms, prepare 41ms)
+
+[?25h

package/README.md

@@ -0,0 +1,57 @@
+# `@lowerdeck/programmable-promise`
+
+Promise with externally controllable resolve and reject. Allows you to create a promise and settle it from outside, useful for complex control flow patterns.
+
+## Installation
+
+```bash
+npm install @lowerdeck/programmable-promise
+yarn add @lowerdeck/programmable-promise
+bun add @lowerdeck/programmable-promise
+pnpm add @lowerdeck/programmable-promise
+```
+
+## Usage
+
+```typescript
+import { ProgrammablePromise } from '@lowerdeck/programmable-promise';
+
+// Create a promise you can control externally
+const pp = new ProgrammablePromise<string>();
+
+// Pass the promise around
+setTimeout(() => {
+  pp.resolve('Hello!');
+}, 1000);
+
+const result = await pp.promise;
+console.log(result); // 'Hello!'
+
+// Useful for event-driven flows
+class EventHandler {
+  private completion = new ProgrammablePromise<void>();
+
+  onComplete() {
+    return this.completion.promise;
+  }
+
+  handleEvent(event: Event) {
+    if (event.type === 'done') {
+      this.completion.resolve();
+    }
+  }
+}
+
+// Access resolved value without awaiting
+const pp2 = new ProgrammablePromise<number>();
+pp2.resolve(42);
+console.log(pp2.value); // 42
+```
+
+## License
+
+This project is licensed under the Apache License 2.0.
+
+<div align="center">
+  <sub>Built with ❤️ by <a href="https://metorial.com">Metorial</a></sub>
+</div>

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@lowerdeck/programmable-promise",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Tobias Herber",
+  "license": "Apache 2",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "require": "./dist/index.cjs",
+    "default": "./dist/index.modern.js"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.module.js",
+  "types": "dist/index.d.ts",
+  "unpkg": "./dist/index.umd.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "lint": "prettier src/**/*.ts --check",
+    "build": "microbundle"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "microbundle": "^0.15.1",
+    "@lowerdeck/tsconfig": "^1.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { ProgrammablePromise } from './index';
+
+describe('ProgrammablePromise', () => {
+  it('should resolve with the provided value', async () => {
+    const promise = new ProgrammablePromise<number>();
+    promise.resolve(42);
+    const result = await promise.promise;
+    expect(result).toBe(42);
+    expect(promise.value).toBe(42);
+  });
+
+  it('should reject with the provided reason', async () => {
+    const promise = new ProgrammablePromise<number>();
+    const error = new Error('Test error');
+    promise.reject(error);
+
+    await expect(promise.promise).rejects.toThrow('Test error');
+  });
+
+  it('should allow accessing the resolved value after resolution', async () => {
+    const promise = new ProgrammablePromise<string>();
+    promise.resolve('Hello, world!');
+    await promise.promise;
+    expect(promise.value).toBe('Hello, world!');
+  });
+
+  it('should not have a value before resolution', () => {
+    const promise = new ProgrammablePromise<number>();
+    expect(promise.value).toBeUndefined();
+  });
+});

package/src/index.ts

@@ -0,0 +1,30 @@
+export class ProgrammablePromise<T> {
+  private _resolve!: (value: T | PromiseLike<T>) => void;
+  private _reject!: (reason?: any) => void;
+  private _promise: Promise<T>;
+  private _value!: T;
+
+  constructor() {
+    this._promise = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  get promise() {
+    return this._promise;
+  }
+
+  resolve(value: T | PromiseLike<T>) {
+    this._resolve(value);
+    this._value = value as T;
+  }
+
+  get reject() {
+    return this._reject;
+  }
+
+  get value() {
+    return this._value;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@lowerdeck/tsconfig/base.json",
+  "exclude": [
+    "dist"
+  ],
+  "include": [
+    "src"
+  ],
+  "compilerOptions": {
+    "outDir": "dist"
+  }
+}