pstream is dead; long live pstream
taciturnaxolotl.github.io/pstream-ng/
improve typings
+86
-48
+31
-20
src/backend/extension/messaging.ts
+31
-20
src/backend/extension/messaging.ts
···
7
7
8
8
let activeExtension = false;
9
9
10
-
export interface ExtensionHello {
11
-
version: string;
12
-
}
13
-
14
-
function sendMessage<T, Payload>(
15
-
message: keyof MessagesMetadata,
16
-
payload: any,
10
+
function sendMessage<MessageKey extends keyof MessagesMetadata>(
11
+
message: MessageKey,
12
+
payload: MessagesMetadata[MessageKey]["req"],
17
13
timeout: number = -1,
18
14
) {
19
-
return new Promise<T | null>((resolve) => {
15
+
return new Promise<MessagesMetadata[MessageKey]["res"] | null>((resolve) => {
20
16
if (timeout >= 0) setTimeout(() => resolve(null), timeout);
21
-
sendToBackgroundViaRelay<Payload, T>({
17
+
sendToBackgroundViaRelay<
18
+
MessagesMetadata[MessageKey]["req"],
19
+
MessagesMetadata[MessageKey]["res"]
20
+
>({
22
21
name: message,
23
22
body: payload,
24
23
})
···
34
33
}
35
34
36
35
export async function sendExtensionRequest(
37
-
url: string,
38
-
ops: any,
39
-
): Promise<ExtensionHello | null> {
40
-
return sendMessage("make-request", { url, ...ops });
36
+
ops: Omit<MessagesMetadata["makeRequest"]["req"], "requestDomain">,
37
+
): Promise<MessagesMetadata["makeRequest"]["res"] | null> {
38
+
return sendMessage("makeRequest", {
39
+
requestDomain: window.location.origin,
40
+
...ops,
41
+
});
41
42
}
42
43
43
44
export async function setDomainRule(
44
-
domains: string[],
45
-
headers: Record<string, string>,
46
-
): Promise<ExtensionHello | null> {
47
-
return sendMessage("prepare-stream", { domains, headers });
45
+
ops: Omit<MessagesMetadata["prepareStream"]["req"], "requestDomain">,
46
+
): Promise<MessagesMetadata["prepareStream"]["res"] | null> {
47
+
return sendMessage("prepareStream", {
48
+
requestDomain: window.location.origin,
49
+
...ops,
50
+
});
48
51
}
49
52
50
-
export async function extensionInfo(): Promise<ExtensionHello | null> {
51
-
return sendMessage("hello", null, 300);
53
+
export async function extensionInfo(): Promise<
54
+
MessagesMetadata["hello"]["res"] | null
55
+
> {
56
+
return sendMessage(
57
+
"hello",
58
+
{
59
+
requestDomain: window.location.origin,
60
+
},
61
+
300,
62
+
);
52
63
}
53
64
54
65
export function isExtensionActiveCached(): boolean {
···
57
68
58
69
export async function isExtensionActive(): Promise<boolean> {
59
70
const info = await extensionInfo();
60
-
if (!info) return false;
71
+
if (!info?.success) return false;
61
72
const allowedVersion = isAllowedExtensionVersion(info.version);
62
73
if (!allowedVersion) return false;
63
74
return true;
+43
-22
src/backend/extension/plasmo.ts
+43
-22
src/backend/extension/plasmo.ts
···
1
-
export interface PlasmoRequestBody {
1
+
export interface ExtensionBaseRequest {
2
+
requestDomain: string;
3
+
}
4
+
5
+
export type ExtensionBaseResponse<T = object> =
6
+
| ({
7
+
success: true;
8
+
} & T)
9
+
| {
10
+
success: false;
11
+
error: string;
12
+
};
13
+
14
+
export type ExtensionHelloResponse = ExtensionBaseResponse<{
15
+
version: string;
16
+
}>;
17
+
18
+
export interface ExtensionMakeRequest extends ExtensionBaseRequest {
19
+
url: string;
20
+
method: string;
21
+
headers?: Record<string, string>;
22
+
body?: string | FormData | URLSearchParams | Record<string, any>;
23
+
}
24
+
25
+
export type ExtensionMakeRequestResponse = ExtensionBaseResponse<{
26
+
status: number;
27
+
requestHeaders: Record<string, string>;
28
+
responseHeaders: Record<string, string>;
29
+
data: string | Record<string, unknown>;
30
+
}>;
31
+
32
+
export interface ExtensionPrepareStreamRequest extends ExtensionBaseRequest {
2
33
ruleId: number;
3
-
domain: string;
34
+
targetDomains: string[];
4
35
requestHeaders?: Record<string, string>;
5
36
responseHeaders?: Record<string, string>;
6
37
}
···
9
40
version: string;
10
41
}
11
42
12
-
export type ExtensionRequestReply =
13
-
| {
14
-
success: true;
15
-
ruleId: number;
16
-
}
17
-
| {
18
-
success: false;
19
-
error: string;
20
-
};
21
-
22
-
interface MmMetadata {
23
-
"prepare-stream": {
24
-
req: PlasmoRequestBody;
25
-
res: ExtensionRequestReply;
43
+
export interface MmMetadata {
44
+
hello: {
45
+
req: ExtensionBaseRequest;
46
+
res: ExtensionHelloResponse;
26
47
};
27
-
"make-request": {
28
-
req: PlasmoRequestBody;
29
-
res: ExtensionRequestReply;
48
+
makeRequest: {
49
+
req: ExtensionMakeRequest;
50
+
res: ExtensionMakeRequestResponse;
30
51
};
31
-
hello: {
32
-
req: null;
33
-
res: ExtensionHelloReply;
52
+
prepareStream: {
53
+
req: ExtensionPrepareStreamRequest;
54
+
res: ExtensionBaseResponse;
34
55
};
35
56
}
36
57
+5
-4
src/backend/extension/streams.ts
+5
-4
src/backend/extension/streams.ts
···
33
33
}
34
34
35
35
export async function prepareStream(stream: Stream) {
36
-
await setDomainRule(
37
-
extractDomainsFromStream(stream),
38
-
buildHeadersFromStream(stream),
39
-
);
36
+
await setDomainRule({
37
+
ruleId: 1,
38
+
targetDomains: extractDomainsFromStream(stream),
39
+
requestHeaders: buildHeadersFromStream(stream),
40
+
});
40
41
}
+7
-2
src/backend/providers/fetchers.ts
+7
-2
src/backend/providers/fetchers.ts
···
54
54
}
55
55
56
56
export function makeExtensionFetcher() {
57
-
const fetcher: Fetcher = async (a, b) => {
58
-
return sendExtensionRequest(a, b) as any;
57
+
const fetcher: Fetcher = async (url, ops) => {
58
+
return sendExtensionRequest({
59
+
url,
60
+
method: ops?.method ?? "GET",
61
+
headers: ops?.headers,
62
+
body: ops?.body,
63
+
}) as any;
59
64
};
60
65
return fetcher;
61
66
}