All files / src/api Completable.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
 
 
 
1x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1x
132x
 
 
 
 
 
 
 
 
 
import { Completion, CompletionState } from "@jonloucks/concurrency-ts/api/Completion";
import { CompletionNotify } from "@jonloucks/concurrency-ts/api/CompletionNotify";
import { IsCompleted } from "@jonloucks/concurrency-ts/api/IsCompleted";
import { OnCompletion } from "@jonloucks/concurrency-ts/api/OnCompletion";
import { OptionalType, RequiredType, guardFunctions } from "@jonloucks/concurrency-ts/api/Types";
import { WaitableNotify } from "@jonloucks/concurrency-ts/api/WaitableNotify";
import { Contracts } from "@jonloucks/contracts-ts/api/Contracts";
import { Open } from "@jonloucks/contracts-ts/api/Open";
 
/**
 * Configuration for a Completable
 *
 * @param <T> the type of completion value  
 */
export interface Config<T> {
  /**
   * Optional contracts for validation or other purposes
   */
  contracts?: Contracts;
 
  /**
   * Optional initial value for the completable
   */
  initialValue?: OptionalType<T>;
}
 
export { Config as CompletableConfig };
 
/**
 * Responsibility: Observe a single activity from start to finish
 *
 * @param <T> the type of completion value
 */
export interface Completable<T> extends Open, CompletionNotify<T>, OnCompletion<T>, IsCompleted {
 
  /**
   * @return observe state change
   */
  notifyState(): WaitableNotify<CompletionState>;
 
  /**
   * @return Observe the completed value
   */
  notifyValue(): WaitableNotify<T>;
 
  /**
   * @return the current completion state
   */
  getCompletion(): OptionalType<Completion<T>>;
}
 
/**
 * Determine if an instance implements Completable
 * 
 * @param instance the instance to check
 * @returns true if the instance implements Completable
 */
export function guard<T>(instance: unknown): instance is RequiredType<Completable<T>> {
  return guardFunctions(instance,
    'open',
    'notifyState',
    'notifyValue',
    'getCompletion',
    'isCompleted',
    'onCompletion',
    'notify'
  );
}