@adviser/cement 0.4.23 → 0.4.25

package/src/resolve-once.ts

@@ -1,11 +1,13 @@
 import { Future } from "./future.js";
-import { isPromise } from "./is-promise.js";
+import { UnPromisify } from "./is-promise.js";
+import { isPromise, Promisable } from "./is-promise.js";
 import { LRUMap, LRUParam, UnregFn } from "./lru-map-set.js";
 import { Result } from "./result.js";
+import { Option } from "./option.js";
 
-interface ResolveSeqItem<T, C> {
+interface ResolveSeqItem<T, C, R extends Promisable<T>> {
   readonly future: Future<T>;
-  readonly fn: (c?: C) => Promise<T>;
+  readonly fn: (c?: C) => R;
   readonly id?: number;
 }
 
@@ -27,145 +29,363 @@ export class ResolveSeq<T, C = void> {
     }
     return Promise.resolve();
   }
-  _step(item?: ResolveSeqItem<T, C>): Promise<void> {
+  async _step<R extends Promisable<T>>(item?: ResolveSeqItem<T, C, R>): Promise<void> {
     if (!item) {
       // done
       this._flushWaiting.forEach((f) => f.resolve());
       this._flushWaiting?.splice(0, this._flushWaiting.length);
       return Promise.resolve();
     }
-    item
-      .fn(this.ctx)
-      .then((value) => item.future.resolve(value))
-      .catch((e) => item.future.reject(e as Error))
-      .finally(() => {
-        this._seqFutures.shift();
-        void this._step(this._seqFutures[0]);
-      });
-    return Promise.resolve();
+    let value;
+    try {
+      const promiseOrValue = item.fn(this.ctx);
+      if (isPromise(promiseOrValue)) {
+        value = await promiseOrValue;
+      } else {
+        value = promiseOrValue;
+      }
+      item.future.resolve(value as T);
+    } catch (e) {
+      item.future.reject(e as Error);
+    } finally {
+      this._seqFutures.shift();
+    }
+    return this._step(this._seqFutures[0]);
   }
-  readonly _seqFutures: ResolveSeqItem<T, C>[] = [];
-  async add(fn: (c?: C) => Promise<T>, id?: number): Promise<T> {
+  readonly _seqFutures: ResolveSeqItem<T, C, Promisable<T>>[] = [];
+  add<R extends Promisable<T>>(fn: (c?: C) => R, id?: number): Promise<UnPromisify<R>> {
     const future = new Future<T>();
     this._seqFutures.push({ future, fn, id });
     if (this._seqFutures.length === 1) {
-      void this._step(this._seqFutures[0]);
+      void this._step(this._seqFutures[0]); // exit into eventloop
     }
-    return future.asPromise();
+    return future.asPromise() as Promise<UnPromisify<R>>;
   }
 }
 
-export class ResolveOnce<T, CTX = void> {
-  _onceDone = false;
-  readonly _onceFutures: Future<T>[] = [];
-  _onceOk = false;
-  _onceValue?: T;
-  _onceError?: Error;
-  _isPromise = false;
-  _inProgress?: Future<T>;
+// readonly _onceFutures: Future<T>[] = [];
+// _onceDone = false;
+// _onceOk = false;
+// _onceValue?: T;
+// _onceError?: Error;
+// _isPromise = false;
+// _inProgress?: Future<T>;
 
-  readonly ctx?: CTX;
+// ResolveOnce
+// cases SyncMode, AsyncMode
 
-  constructor(ctx?: CTX) {
-    this.ctx = ctx;
+type ResolveState = "initial" | "processed" | "waiting" | "processing";
+
+interface ResolveOnceIf<T extends Promisable<unknown>, CTX = void> {
+  get ready(): boolean;
+  get value(): UnPromisify<T> | undefined;
+  get error(): Error | undefined;
+  get state(): ResolveState;
+
+  once<R extends Promisable<UnPromisify<T>>>(fn: (c?: CTX) => R): R;
+  reset<R extends Promisable<UnPromisify<T>>>(fn?: (c?: CTX) => R): R;
+}
+
+export class SyncResolveOnce<T extends Promisable<unknown>, CTX = void> {
+  state: ResolveState = "initial";
+
+  #value?: T;
+  #error?: Error;
+
+  readonly queueLength = 0;
+
+  get value(): T | undefined {
+    return this.#value;
+  }
+
+  get error(): Error | undefined {
+    return this.#error;
   }
 
   get ready(): boolean {
-    return this._onceDone;
+    return this.state === "processed";
   }
 
-  get value(): T | undefined {
-    return this._onceDone ? this._onceValue : undefined;
+  readonly #ctx?: CTX;
+  constructor(ctx?: CTX) {
+    this.#ctx = ctx;
   }
 
-  reset(): void {
-    this._onceDone = false;
-    this._onceOk = false;
-    this._onceValue = undefined;
-    this._onceError = undefined;
-    if (this._inProgress) {
-      const idx = this._onceFutures.findIndex((f) => f === this._inProgress);
-      if (idx >= 0) {
-        // leave the current in progress future
-        this._onceFutures.push(...this._onceFutures.splice(2).slice(1));
+  resolve(fn: (ctx?: CTX) => T): T {
+    if (this.state === "initial") {
+      this.state = "processed";
+      try {
+        this.#value = fn(this.#ctx);
+      } catch (e) {
+        this.#error = e as Error;
       }
-    } else {
-      this._onceFutures.length = 0;
+      if (isPromise(this.value)) {
+        throw new Error("SyncResolveOnce.once fn returned a promise");
+      }
+    }
+    if (this.#error) {
+      throw this.#error;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    return this.#value as T;
   }
 
-  // T extends Option<infer U> ? U : T
-  once<R>(fn: (c?: CTX) => R): R {
-    if (this._onceDone) {
-      if (this._onceError) {
-        if (this._isPromise) {
-          return Promise.reject(this._onceError) as unknown as R;
-        } else {
-          throw this._onceError;
-        }
-      }
-      if (this._onceOk) {
-        if (this._isPromise) {
-          return Promise.resolve(this._onceValue) as unknown as R;
+  reset(fn?: (c?: CTX) => T): T | undefined {
+    this.state = "initial";
+    this.#value = undefined;
+    this.#error = undefined;
+    if (fn) {
+      return this.resolve(fn);
+    }
+    return undefined as T;
+  }
+}
+
+class AsyncResolveItem<T extends Promisable<unknown>> {
+  readonly id = Math.random();
+  #state: ResolveState = "initial";
+  readonly #toResolve: Promise<UnPromisify<T>>;
+  #value: Option<UnPromisify<T>> = Option.None();
+  #error?: Error;
+
+  constructor(fn: Promise<UnPromisify<T>>) {
+    this.#toResolve = fn;
+  }
+
+  get value(): UnPromisify<T> | undefined {
+    return this.#value.IsSome() ? this.#value.unwrap() : undefined;
+  }
+
+  get error(): Error | undefined {
+    return this.#error;
+  }
+
+  readonly #queue: Future<UnPromisify<T>>[] = [];
+
+  get queuelength(): number {
+    return this.#queue.length;
+  }
+
+  isDisposable(): boolean {
+    return this.#state === "processed" && this.#queue.length === 0;
+  }
+
+  #resolveFuture(future?: Future<UnPromisify<T>>): void {
+    if (!future) {
+      return;
+    }
+    if (this.#error) {
+      future.reject(this.#error);
+      return;
+    }
+    if (this.#value.IsSome()) {
+      future.resolve(this.#value.Unwrap());
+    }
+  }
+
+  #promiseResult(): Promise<UnPromisify<T>> {
+    if (this.#error) {
+      return Promise.reject(this.#error);
+    }
+    if (this.#value.IsSome()) {
+      return Promise.resolve(this.#value.Unwrap());
+    }
+    throw new Error("AsyncResolveItem.#promiseResult impossible");
+  }
+
+  resolve(): T {
+    if (this.#state === "initial") {
+      this.#state = "waiting";
+      const future = new Future<UnPromisify<T>>();
+      // console.log("asyncItem addQueue#initial", this.id, this.#queue.length);
+      this.#queue.push(future);
+      this.#toResolve
+        .then((value) => {
+          this.#value = Option.Some(value);
+        })
+        .catch((e) => {
+          this.#error = e as Error;
+        })
+        .finally(() => {
+          this.#state = "processed";
+          while (this.#queue.length > 0) {
+            this.#resolveFuture(this.#queue.shift());
+          }
+        });
+      return future.asPromise() as T;
+    }
+    if (this.#state === "processed") {
+      return this.#promiseResult() as T;
+    }
+    if (this.#state === "waiting") {
+      const future = new Future<UnPromisify<T>>();
+      // console.log("asyncItem addQueue#waiting", this.id, this.#queue.length);
+      this.#queue.push(future);
+      return future.asPromise() as T;
+    }
+    throw new Error("AsyncResolveItem.resolve impossible");
+  }
+}
+
+export class AsyncResolveOnce<T extends Promisable<unknown>, CTX = void> {
+  // readonly id = Math.random();
+  state: ResolveState = "initial";
+
+  readonly #queue: AsyncResolveItem<T>[] = [];
+
+  readonly #ctx?: CTX;
+  constructor(ctx?: CTX) {
+    this.#ctx = ctx;
+  }
+
+  #active(): AsyncResolveItem<T> {
+    const r = this.#queue[this.#queue.length - 1];
+    if (!r) {
+      throw new Error("AsyncResolveOnce.#active impossible");
+    }
+    return r;
+  }
+
+  get queueLength(): number {
+    return this.#queue.reduce((acc, r) => acc + r.queuelength, this.#queue.length);
+  }
+
+  get ready(): boolean {
+    return this.state !== "initial";
+  }
+  get value(): UnPromisify<T> | undefined {
+    if (this.state === "initial") {
+      return undefined;
+    }
+    return this.#active().value;
+  }
+
+  get error(): Error | undefined {
+    if (this.state === "initial") {
+      return undefined;
+    }
+    return this.#active().error;
+  }
+
+  resolve(fn: (ctx?: CTX) => T): T {
+    if (this.state === "initial") {
+      this.state = "waiting";
+      let promiseResult: Promise<UnPromisify<T>>;
+      try {
+        const couldBePromise = fn(this.#ctx);
+        if (!isPromise(couldBePromise)) {
+          promiseResult = Promise.resolve(couldBePromise as UnPromisify<T>);
         } else {
-          return this._onceValue as unknown as R;
+          promiseResult = couldBePromise as Promise<UnPromisify<T>>;
         }
+      } catch (e) {
+        promiseResult = Promise.reject(e as Error);
       }
-      throw new Error("ResolveOnce.once impossible");
+      // console.log("asyncOnce addQueue#initial", this.id, this.#queue.length);
+      this.#queue.push(new AsyncResolveItem(promiseResult));
     }
-    const future = new Future<T>();
-    this._onceFutures.push(future);
-    if (this._onceFutures.length === 1) {
-      const okFn = (value: T): void => {
-        this._onceValue = value;
-        this._onceOk = true;
-        this._onceDone = true;
-        if (this._isPromise) {
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
-          this._onceFutures.forEach((f) => f.resolve(this._onceValue!));
-        }
-        this._onceFutures.length = 0;
-      };
-      const catchFn = (e: Error): void => {
-        this._onceError = e;
-        this._onceOk = false;
-        this._onceValue = undefined;
-        this._onceDone = true;
-        if (this._isPromise) {
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
-          this._onceFutures.forEach((f) => f.reject(this._onceError!));
-        }
-        this._onceFutures.length = 0;
-      };
-      this._inProgress = future;
-      // let inCriticalSection = false;
+    // remove all disposable items
+    this.#queue
+      .slice(0, -1)
+      .map((i, idx) => (i.isDisposable() ? idx : undefined))
+      .filter((i) => i !== undefined)
+      .reverse()
+      .forEach((idx) => this.#queue.splice(idx, 1));
+
+    return this.#active().resolve();
+  }
+
+  reset(fn?: (c?: CTX) => T): T {
+    this.state = "initial";
+    if (fn) {
+      return this.resolve(fn);
+    }
+    return undefined as T;
+  }
+}
+
+export class ResolveOnce<T extends Promisable<unknown>, CTX = void> implements ResolveOnceIf<T, CTX> {
+  #state: ResolveState = "initial";
+
+  #syncOrAsync: Option<SyncResolveOnce<never, CTX> | AsyncResolveOnce<never, CTX>> = Option.None();
+
+  readonly #ctx?: CTX;
+  constructor(ctx?: CTX) {
+    this.#ctx = ctx;
+  }
+
+  get ready(): boolean {
+    return this.#state !== "initial" && this.#syncOrAsync.Unwrap().ready;
+  }
+
+  get value(): UnPromisify<T> | undefined {
+    if (this.#state === "initial") {
+      return undefined;
+    }
+    return this.#syncOrAsync.Unwrap().value as UnPromisify<T>;
+  }
+
+  get queueLength(): number {
+    if (this.#state === "initial") {
+      return 0;
+    }
+    return this.#syncOrAsync.Unwrap().queueLength;
+  }
+
+  get error(): Error | undefined {
+    if (this.#state === "initial") {
+      return undefined;
+    }
+    return this.#syncOrAsync.Unwrap().error;
+  }
+
+  get state(): ResolveState {
+    if (this.#state === "initial") {
+      return "initial";
+    }
+    return this.#syncOrAsync.Unwrap().state;
+  }
+
+  once<R extends Promisable<UnPromisify<T>>>(fn: (c?: CTX) => R): R {
+    let resultFn: (ctx?: CTX) => R;
+    if (this.#state === "initial") {
+      this.#state = "processing";
       try {
-        const ret = fn(this.ctx);
-        if (isPromise(ret)) {
-          this._isPromise = true;
-          // inCriticalSection = true;
-          (ret as Promise<T>)
-            .then(okFn)
-            .catch(catchFn)
-            .finally(() => {
-              this._inProgress = undefined;
-            });
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        const isSyncOrAsync = fn(this.#ctx) as R;
+        if (isPromise(isSyncOrAsync)) {
+          this.#syncOrAsync = Option.Some(new AsyncResolveOnce<never, CTX>(this.#ctx));
         } else {
-          okFn(ret as unknown as T);
+          this.#syncOrAsync = Option.Some(new SyncResolveOnce<never, CTX>(this.#ctx));
         }
+        resultFn = (): R => isSyncOrAsync;
       } catch (e) {
-        catchFn(e as Error);
-      }
-      if (!this._isPromise) {
-        this._inProgress = undefined;
+        this.#syncOrAsync = Option.Some(new SyncResolveOnce<never, CTX>(this.#ctx));
+        resultFn = (): R => {
+          throw e;
+        };
+      } finally {
+        this.#state = "processed";
       }
-    }
-    if (this._isPromise) {
-      return future.asPromise() as unknown as R;
     } else {
-      // abit funky but i don't want to impl the return just once
-      return this.once(fn);
+      resultFn = fn;
+    }
+    if (!this.#syncOrAsync) {
+      throw new Error("ResolveOnce.once impossible");
     }
+    return this.#syncOrAsync.Unwrap().resolve(resultFn as (c?: CTX) => never) as R;
+  }
+
+  reset<R extends Promisable<UnPromisify<T>>>(fn?: (c?: CTX) => R): R {
+    if (this.#state === "initial") {
+      return this.once(fn as (c?: CTX) => R);
+    }
+    if (this.#state === "processing") {
+      // eslint-disable-next-line no-console
+      console.warn("ResolveOnce.reset dropped was called while processing");
+      return undefined as R;
+    }
+    return this.#syncOrAsync.Unwrap().reset(fn as (c?: CTX) => never) as R;
   }
 }
 
@@ -175,6 +395,7 @@ export interface KeyedParam {
 
 export class Keyed<T extends { reset: () => void }, K = string> {
   protected readonly _map: LRUMap<K, T>;
+  // #lock = new ResolveSeq<T, K>();
 
   readonly factory: (key: K) => T;
   constructor(factory: (key: K) => T, params: Partial<KeyedParam>) {
@@ -217,6 +438,14 @@ export class Keyed<T extends { reset: () => void }, K = string> {
     return this._map.has(key);
   }
 
+  // lock<R extends Promisable<T>>(fn: (map: LRUMap<K, T>) => R): Promise<UnPromisify<R>>  {
+  //   return this.#lock.add(() => fn(this._map));
+  // }
+
+  delete(key: K): void {
+    this._map.delete(key);
+  }
+
   unget(key: K): void {
     const keyed = this._map.get(key);
     keyed?.reset();
@@ -241,14 +470,13 @@ export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K>
 
   *entries(): IterableIterator<KeyItem<K, T>> {
     for (const [k, v] of this._map.entries()) {
-      if (!v._onceDone) {
+      if (!v.ready) {
         continue;
       }
-      if (v._onceError) {
-        yield { key: k, value: Result.Err<T>(v._onceError) };
+      if (v.error) {
+        yield { key: k, value: Result.Err<T>(v.error) };
       } else {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
-        yield { key: k, value: Result.Ok<T>(v._onceValue!) };
+        yield { key: k, value: Result.Ok<T>(v.value as T) };
       }
     }
   }
@@ -268,15 +496,15 @@ export class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
   }
 }
 
-class LazyContainer<T> {
+class LazyContainer<T extends Promisable<unknown>> {
   readonly resolveOnce = new ResolveOnce<T>();
 
-  call<R>(fn: () => R): () => ReturnType<typeof fn> {
+  call<R extends Promisable<UnPromisify<T>>>(fn: () => R): () => ReturnType<typeof fn> {
     return () => this.resolveOnce.once(fn);
   }
 }
 
-export function Lazy<R>(fn: () => R): () => ReturnType<typeof fn> {
-  const lazy = new LazyContainer();
-  return lazy.call(fn);
+export function Lazy<R extends Promisable<unknown>>(fn: () => R): () => ReturnType<typeof fn> {
+  const lazy = new LazyContainer<R>();
+  return lazy.call(fn as () => Promisable<UnPromisify<R>>) as () => ReturnType<typeof fn>;
 }

package/ts/cjs/future.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"future.d.ts","sourceRoot":"","sources":["../../../src/future.ts"],"names":[],"mappings":"AAAA,qBAAa,MAAM,CAAC,CAAC;;IASnB,cAKC;IAEK,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC,CAE5B;IAED,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAEtB;IACD,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAE5B;CACF"}
+{"version":3,"file":"future.d.ts","sourceRoot":"","sources":["../../../src/future.ts"],"names":[],"mappings":"AAAA,qBAAa,MAAM,CAAC,CAAC;;IAUnB,cAKC;IAED,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC,CAEtB;IAED,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAEtB;IACD,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAE5B;CACF"}

package/ts/cjs/future.js

@@ -15,7 +15,7 @@ class Future {
             this.#rejectFn = reject;
         });
     }
-    async asPromise() {
+    asPromise() {
         return this.#promise;
     }
     resolve(value) {

package/ts/cjs/future.js.map

@@ -1 +1 @@
-{"version":3,"file":"future.js","sourceRoot":"","sources":["../../../src/future.ts"],"names":[],"mappings":";;;AAAA;IACW,QAAQ,CAAa;IAC9B,UAAU,GAAuB,GAAG,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAAA,CAC7D,CAAC;IACF,SAAS,GAA8B,GAAG,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAAA,CAC7D,CAAC;IAEF,cAAc;QACZ,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;YAClD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QAAA,CACzB,CAAC,CAAC;IAAA,CACJ;IAED,KAAK,CAAC,SAAS,GAAe;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC;IAAA,CACtB;IAED,OAAO,CAAC,KAAQ,EAAQ;QACtB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAAA,CACxB;IACD,MAAM,CAAC,MAAe,EAAQ;QAC5B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAAA,CACxB;CACF"}
+{"version":3,"file":"future.js","sourceRoot":"","sources":["../../../src/future.ts"],"names":[],"mappings":";;;AAAA;IAEW,QAAQ,CAAa;IAC9B,UAAU,GAAuB,GAAG,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAAA,CAC7D,CAAC;IACF,SAAS,GAA8B,GAAG,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAAA,CAC7D,CAAC;IAEF,cAAc;QACZ,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;YAClD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QAAA,CACzB,CAAC,CAAC;IAAA,CACJ;IAED,SAAS,GAAe;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC;IAAA,CACtB;IAED,OAAO,CAAC,KAAQ,EAAQ;QACtB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAAA,CACxB;IACD,MAAM,CAAC,MAAe,EAAQ;QAC5B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAAA,CACxB;CACF"}

package/ts/cjs/is-promise.d.ts

@@ -1,5 +1,7 @@
 export type UnPromisify<T> = T extends Promise<infer U> ? U : T;
 export type WithoutPromise<T> = UnPromisify<T>;
+export type IsNotPromise<T> = T extends Promise<never> ? never : T;
 export type Promisable<T> = T | Promise<T>;
 export declare function isPromise<T>(a: T): a is T extends Promise<unknown> ? T : never;
+export declare function isNotPromise<T>(a: T): T;
 //# sourceMappingURL=is-promise.d.ts.map

package/ts/cjs/is-promise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-promise.d.ts","sourceRoot":"","sources":["../../../src/is-promise.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAE/C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3C,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAY9E"}
+{"version":3,"file":"is-promise.d.ts","sourceRoot":"","sources":["../../../src/is-promise.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAE/C,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAEnE,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3C,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAY9E;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAEvC"}

package/ts/cjs/is-promise.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPromise = isPromise;
+exports.isNotPromise = isNotPromise;
 function isPromise(a) {
     const mayBe = a;
     return (mayBe instanceof Promise ||
@@ -10,4 +11,7 @@ function isPromise(a) {
             typeof mayBe.catch === "function" &&
             typeof mayBe.finally === "function"));
 }
+function isNotPromise(a) {
+    return !isPromise(a);
+}
 //# sourceMappingURL=is-promise.js.map

package/ts/cjs/is-promise.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-promise.js","sourceRoot":"","sources":["../../../src/is-promise.ts"],"names":[],"mappings":";;;AAKA,mBAA6B,CAAI,EAA+C;IAC9E,MAAM,KAAK,GAAG,CAA4E,CAAC;IAC3F,OAAO,CACL,KAAK,YAAY,OAAO;QACxB,CAAC,CAAC,CACA,KAAK;YACL,KAAK,KAAK,IAAI;YACd,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;YAChC,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;YACjC,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CACpC,CACF,CAAC;AAAA,CACH"}
+{"version":3,"file":"is-promise.js","sourceRoot":"","sources":["../../../src/is-promise.ts"],"names":[],"mappings":";;;;AAOA,mBAA6B,CAAI,EAA+C;IAC9E,MAAM,KAAK,GAAG,CAA4E,CAAC;IAC3F,OAAO,CACL,KAAK,YAAY,OAAO;QACxB,CAAC,CAAC,CACA,KAAK;YACL,KAAK,KAAK,IAAI;YACd,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;YAChC,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;YACjC,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CACpC,CACF,CAAC;AAAA,CACH;AAED,sBAAgC,CAAI,EAAK;IACvC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAM,CAAC;AAAA,CAC3B"}

package/ts/cjs/option.d.ts

@@ -3,6 +3,7 @@ export declare abstract class Option<T> {
     static None<T>(): Option<T>;
     static Is<T>(t: unknown): t is Option<T>;
     static From<T>(t?: T): Option<T>;
+    toValue(): T | undefined;
     IsNone(): boolean;
     IsSome(): boolean;
     Unwrap(): T;

package/ts/cjs/option.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../../../src/option.ts"],"names":[],"mappings":"AAAA,8BAAsB,MAAM,CAAC,CAAC;IAC5B,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAE9B;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAE1B;IAED,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAEvC;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAK/B;IAED,MAAM,IAAI,OAAO,CAEhB;IAED,MAAM,IAAI,OAAO,CAEhB;IACD,MAAM,IAAI,CAAC,CAEV;IAED,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC;IAC5B,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;CACtB;AAED,qBAAa,IAAI,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,CAAI;IACd,YAAY,EAAE,EAAE,CAAC,EAGhB;IAED,OAAO,IAAI,OAAO,CAEjB;IACD,OAAO,IAAI,OAAO,CAEjB;IACD,MAAM,IAAI,CAAC,CAEV;CACF;AAED,qBAAa,IAAI,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACpC,OAAO,IAAI,OAAO,CAEjB;IACD,OAAO,IAAI,OAAO,CAEjB;IACD,MAAM,IAAI,CAAC,CAEV;CACF;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../../../src/option.ts"],"names":[],"mappings":"AAAA,8BAAsB,MAAM,CAAC,CAAC;IAC5B,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAE9B;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAE1B;IAED,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAEvC;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAK/B;IAED,OAAO,IAAI,CAAC,GAAG,SAAS,CAEvB;IAED,MAAM,IAAI,OAAO,CAEhB;IAED,MAAM,IAAI,OAAO,CAEhB;IACD,MAAM,IAAI,CAAC,CAEV;IAED,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC;IAC5B,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;CACtB;AAED,qBAAa,IAAI,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,CAAI;IACd,YAAY,EAAE,EAAE,CAAC,EAGhB;IAED,OAAO,IAAI,OAAO,CAEjB;IACD,OAAO,IAAI,OAAO,CAEjB;IACD,MAAM,IAAI,CAAC,CAEV;CACF;AAED,qBAAa,IAAI,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACpC,OAAO,IAAI,OAAO,CAEjB;IACD,OAAO,IAAI,OAAO,CAEjB;IACD,MAAM,IAAI,CAAC,CAEV;CACF;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC"}

package/ts/cjs/option.js

@@ -17,6 +17,9 @@ class Option {
         }
         return new Some(t);
     }
+    toValue() {
+        return this.is_some() ? this.unwrap() : undefined;
+    }
     IsNone() {
         return this.is_none();
     }

package/ts/cjs/option.js.map

@@ -1 +1 @@
-{"version":3,"file":"option.js","sourceRoot":"","sources":["../../../src/option.ts"],"names":[],"mappings":";;;AAAA;IACE,MAAM,CAAC,IAAI,CAAI,CAAI,EAAa;QAC9B,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAAA,CACpB;IAED,MAAM,CAAC,IAAI,GAAiB;QAC1B,OAAO,IAAI,IAAI,EAAE,CAAC;IAAA,CACnB;IAED,MAAM,CAAC,EAAE,CAAI,CAAU,EAAkB;QACvC,OAAO,CAAC,YAAY,MAAM,CAAC;IAAA,CAC5B;IAED,MAAM,CAAC,IAAI,CAAI,CAAK,EAAa;QAC/B,IAAI,CAAC,CAAC,EAAE,CAAC;YACP,OAAO,IAAI,IAAI,EAAE,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAAA,CACpB;IAED,MAAM,GAAY;QAChB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IAAA,CACvB;IAED,MAAM,GAAY;QAChB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IAAA,CACvB;IACD,MAAM,GAAM;QACV,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IAAA,CACtB;CAKF;;AAED,UAAqB,SAAQ,MAAS;IAC5B,EAAE,CAAI;IACd,YAAY,EAAK,EAAE;QACjB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAAA,CACd;IAED,OAAO,GAAY;QACjB,OAAO,KAAK,CAAC;IAAA,CACd;IACD,OAAO,GAAY;QACjB,OAAO,IAAI,CAAC;IAAA,CACb;IACD,MAAM,GAAM;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IAAA,CAChB;CACF;;AAED,UAAqB,SAAQ,MAAS;IACpC,OAAO,GAAY;QACjB,OAAO,IAAI,CAAC;IAAA,CACb;IACD,OAAO,GAAY;QACjB,OAAO,KAAK,CAAC;IAAA,CACd;IACD,MAAM,GAAM;QACV,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;IAAA,CAChC;CACF"}
+{"version":3,"file":"option.js","sourceRoot":"","sources":["../../../src/option.ts"],"names":[],"mappings":";;;AAAA;IACE,MAAM,CAAC,IAAI,CAAI,CAAI,EAAa;QAC9B,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAAA,CACpB;IAED,MAAM,CAAC,IAAI,GAAiB;QAC1B,OAAO,IAAI,IAAI,EAAE,CAAC;IAAA,CACnB;IAED,MAAM,CAAC,EAAE,CAAI,CAAU,EAAkB;QACvC,OAAO,CAAC,YAAY,MAAM,CAAC;IAAA,CAC5B;IAED,MAAM,CAAC,IAAI,CAAI,CAAK,EAAa;QAC/B,IAAI,CAAC,CAAC,EAAE,CAAC;YACP,OAAO,IAAI,IAAI,EAAE,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;IAAA,CACpB;IAED,OAAO,GAAkB;QACvB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAAA,CACnD;IAED,MAAM,GAAY;QAChB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IAAA,CACvB;IAED,MAAM,GAAY;QAChB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IAAA,CACvB;IACD,MAAM,GAAM;QACV,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IAAA,CACtB;CAKF;;AAED,UAAqB,SAAQ,MAAS;IAC5B,EAAE,CAAI;IACd,YAAY,EAAK,EAAE;QACjB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAAA,CACd;IAED,OAAO,GAAY;QACjB,OAAO,KAAK,CAAC;IAAA,CACd;IACD,OAAO,GAAY;QACjB,OAAO,IAAI,CAAC;IAAA,CACb;IACD,MAAM,GAAM;QACV,OAAO,IAAI,CAAC,EAAE,CAAC;IAAA,CAChB;CACF;;AAED,UAAqB,SAAQ,MAAS;IACpC,OAAO,GAAY;QACjB,OAAO,IAAI,CAAC;IAAA,CACb;IACD,OAAO,GAAY;QACjB,OAAO,KAAK,CAAC;IAAA,CACd;IACD,MAAM,GAAM;QACV,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;IAAA,CAChC;CACF"}