transporter/types.ts at main · clappcodes/transporter · GitHub

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
// declare global {
//   const readable: typeof import("./readable/mod.ts");
//   const writable: typeof import("./writable/mod.ts");
//   const transform: typeof import("./transform/mod.ts");
//   const transport: typeof import("./transport/mod.ts");

//   const Transporter: {
//     readable: typeof readable;
//     writable: typeof writable;
//     transform: typeof transform;
//     transport: typeof transport;
//   };
// }

export type Readable<T> = ReadableStream<T>;
export type Writable<T> = WritableStream<T>;
export type Observable<T> = ReadableStream<T>;
export type Transform<I, O = I> = TransformStream<I, O>;

export type ResponseStatus =
  | `100 Continue`
  | `101 Switching Protocols`
  | `102 Processing`
  | `103 Early Hints`
  | `200 OK`
  | `201 Created`
  | `202 Accepted`
  | `203 Non-Authoritative Information`
  | `204 No Content`
  | `205 Reset Content`
  | `206 Partial Content`
  | `300 Multiple Choices`
  | `301 Moved Permanently`
  | `302 Found`
  | `303 See Other`
  | `304 Not Modified`
  | `305 Use Proxy`
  | `306 Unused`
  | `307 Temporary Redirect`
  | `308 Permanent Redirect`
  | `400 Bad Request`
  | `401 Unauthorized`
  | `402 Payment Required`
  | `403 Forbidden`
  | `404 Not Found`
  | `405 Method Not Allowed`
  | `406 Not Acceptable`
  | `407 Proxy Authentication Required`
  | `408 Request Timeout`
  | `409 Conflict`
  | `410 Gone`
  | `411 Length Required`
  | `412 Precondition Failed`
  | `413 Request Entity Too Large`
  | `414 Request-URI Too Long`
  | `415 Unsupported Media Type`
  | `416 Requested Range Not Satisfiable`
  | `417 Expectation Failed`
  | `418 I'm a teapot`
  | `421 Misdirected Request`
  | `422 Unprocessable Entity`
  | `423 Locked`
  | `425 Too Early`
  | `426 Upgrade Required`
  | `428 Precondition Required`
  | `429 Too Many Requests`
  | `431 Request Header Fields Too Large`
  | `451 Unavailable For Legal Reasons`
  | `500 Internal Server Error`
  | `501 Not Implemented`
  | `502 Bad Gateway`
  | `503 Service Unavailable`
  | `504 Gateway Timeout`
  | `505 HTTP Version Not Supported`
  | `506 Variant Also Negotiates`
  | `507 Insufficient Storage`
  | `511 Network Authentication Required`
  | `520 Web server is returning an unknown error`
  | `522 Connection timed out`
  | `524 A timeout occurred`;

export interface Incoming<T> extends Readable<T> {
  url?: URL | string;
}

export interface Outgoing<T> extends Writable<T> {
  url?: URL | string;
}

export interface Transport<I, O = I> {
  readonly incoming: Incoming<I>;
  readonly outgoing: Outgoing<O>;
}

export type StrictStream<Type> = ReadableStream<Type>;
export type StrictStreamOf<Input> = StrictStream<Input> & {
  pipe<Output>(
    mapper: StrictStreamMapper<Input, Output>,
  ): StrictStreamOf<Output>;
};

export type StrictStreamLike<Type> =
  | ReadableStream<Type>
  | Readable<Type>;

export type StrictStreamMapper<Input, Output> = (
  stream: StrictStream<Input>,
) => StrictStream<Output>;

export type Promised<Type> = Type | Promise<Type>;

export type StrictStreamPlumber<In, Out> = StrictStreamMapper<In, Out> & {
  pipe<Output>(
    mapper: StrictStreamMapper<Out, Output> | TransformStream<Out, Output>,
  ): StrictStreamPlumber<In, Output>;
};