rong 0.2.0

RongJS runtime and embedding API
Documentation 
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
117
118
119
120
121
122
123
124
125
126
127
128

describe("AbortSignal", () => {
  describe("Basic functionality", () => {
    it("should throw error when trying to create AbortSignal with new", () => {
      try {
        new AbortSignal();
      } catch (error) {
        expect(error.message).toContain("Illegal constructor");
      }
    });

    it("should create a new AbortSignal instance via AbortController", () => {
      const controller = new AbortController();
      const signal = controller.signal;
      expect(signal.aborted).toBeFalsy();
      expect(signal.reason).toBeUndefined();
    });

    it("should handle abort event", (done) => {
      const controller = new AbortController();
      const signal = controller.signal;
      signal.onabort = () => {
        expect(signal.aborted).toBeTruthy();
        done();
      };
      controller.abort();
    });
  });

  describe("Static methods", () => {
    it("should create aborted signal with abort()", () => {
      const reason = new Error("Aborted");
      const signal = AbortSignal.abort(reason);
      expect(signal.aborted).toBeTruthy();
      expect(signal.reason).toBe(reason);
    });

    it("should create signal from multiple signals with any()", () => {
      const controller1 = new AbortController();
      const controller2 = new AbortController();
      const controller3 = new AbortController();

      const signal1 = controller1.signal;
      const signal2 = controller2.signal;
      const signal3 = controller3.signal;

      const combinedSignal = AbortSignal.any([signal1, signal2, signal3]);
      expect(combinedSignal.aborted).toBeFalsy();

      const reason = new Error("Test abort");
      controller2.abort(reason);

      expect(combinedSignal.aborted).toBeTruthy();
      expect(combinedSignal.reason).toBe(reason);
    });

    it("should abort immediately if any input signal is already aborted", () => {
      const controller1 = new AbortController();
      const signal2 = AbortSignal.abort("Already aborted");
      const controller3 = new AbortController();

      const combinedSignal = AbortSignal.any([
        controller1.signal,
        signal2,
        controller3.signal,
      ]);
      expect(combinedSignal.aborted).toBeTruthy();
      expect(combinedSignal.reason).toBe("Already aborted");
    });

    describe("timeout", () => {
      it("should create an AbortSignal that aborts after the specified time", async () => {
        const timeoutDuration = 100; // 100ms
        const signal = AbortSignal.timeout(timeoutDuration);

        // Wait for the signal to be aborted
        await new Promise((resolve, reject) => {
          signal.addEventListener("abort", () => {
            try {
              console.log("Abort event triggered");
              expect(signal.aborted).toBe(true);
              expect(signal.reason).toBeInstanceOf(DOMException);
              resolve();
            } catch (e) {
              reject(e);
            }
          });

          // Ensure the signal is not aborted before the timeout
          setTimeout(() => {
            try {
              expect(signal.aborted).toBe(false);
            } catch (e) {
              reject(e);
            }
          }, timeoutDuration / 2);

          setTimeout(() => {
            reject(new Error("Signal did not abort within expected time"));
          }, timeoutDuration * 2);
        });
      });
    });
  });

  describe("Error handling", () => {
    it("should throw if aborted with string reason", () => {
      const signal = AbortSignal.abort("Test reason");
      expect(() => signal.throwIfAborted()).toThrow("Test reason");
    });

    it("should throw if aborted with object reason", () => {
      const reason = { message: "Test reason" };
      const signal = AbortSignal.abort(reason);
      expect(() => signal.throwIfAborted()).toThrow(reason);
    });

    it("should throw TypeError if aborted with TypeError", () => {
      const signal = AbortSignal.abort(new TypeError("Type error"));
      expect(() => signal.throwIfAborted()).toThrow(TypeError);
    });

    it("should not throw if not aborted", () => {
      const controller = new AbortController();
      const signal = controller.signal;
      assert.doesNotThrow(() => signal.throwIfAborted());
    });
  });
});