@cloudbase/framework-plugin-low-code 0.4.45 → 0.5.1

package/template/node_modules/comlink/tests/same_window.comlink.test.js

@@ -1,587 +0,0 @@
-/**
- * Copyright 2017 Google Inc. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import * as Comlink from "/base/dist/esm/comlink.mjs";
-
-class SampleClass {
-  constructor(counterInit = 1) {
-    this._counter = counterInit;
-    this._promise = Promise.resolve(4);
-  }
-
-  static get SOME_NUMBER() {
-    return 4;
-  }
-
-  static ADD(a, b) {
-    return a + b;
-  }
-
-  get counter() {
-    return this._counter;
-  }
-
-  set counter(value) {
-    this._counter = value;
-  }
-
-  get promise() {
-    return this._promise;
-  }
-
-  method() {
-    return 4;
-  }
-
-  increaseCounter(delta = 1) {
-    this._counter += delta;
-  }
-
-  promiseFunc() {
-    return new Promise((resolve) => setTimeout((_) => resolve(4), 100));
-  }
-
-  proxyFunc() {
-    return Comlink.proxy({
-      counter: 0,
-      inc() {
-        this.counter++;
-      },
-    });
-  }
-
-  throwsAnError() {
-    throw Error("OMG");
-  }
-}
-
-describe("Comlink in the same realm", function () {
-  beforeEach(function () {
-    const { port1, port2 } = new MessageChannel();
-    port1.start();
-    port2.start();
-    this.port1 = port1;
-    this.port2 = port2;
-  });
-
-  it("can work with objects", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose({ value: 4 }, this.port2);
-    expect(await thing.value).to.equal(4);
-  });
-
-  it("can work with functions on an object", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose({ f: (_) => 4 }, this.port2);
-    expect(await thing.f()).to.equal(4);
-  });
-
-  it("can work with functions", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((_) => 4, this.port2);
-    expect(await thing()).to.equal(4);
-  });
-
-  it("can work with objects that have undefined properties", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose({ x: undefined }, this.port2);
-    expect(await thing.x).to.be.undefined;
-  });
-
-  it("can keep the stack and message of thrown errors", async function () {
-    let stack;
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((_) => {
-      const error = Error("OMG");
-      stack = error.stack;
-      throw error;
-    }, this.port2);
-    try {
-      await thing();
-      throw "Should have thrown";
-    } catch (err) {
-      expect(err).to.not.eq("Should have thrown");
-      expect(err.message).to.equal("OMG");
-      expect(err.stack).to.equal(stack);
-    }
-  });
-
-  it("can forward an async function error", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(
-      {
-        async throwError() {
-          throw new Error("Should have thrown");
-        },
-      },
-      this.port2
-    );
-    try {
-      await thing.throwError();
-    } catch (err) {
-      expect(err.message).to.equal("Should have thrown");
-    }
-  });
-
-  it("can rethrow non-error objects", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((_) => {
-      throw { test: true };
-    }, this.port2);
-    try {
-      await thing();
-      throw "Should have thrown";
-    } catch (err) {
-      expect(err).to.not.equal("Should have thrown");
-      expect(err.test).to.equal(true);
-    }
-  });
-
-  it("can rethrow scalars", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((_) => {
-      throw "oops";
-    }, this.port2);
-    try {
-      await thing();
-      throw "Should have thrown";
-    } catch (err) {
-      expect(err).to.not.equal("Should have thrown");
-      expect(err).to.equal("oops");
-      expect(typeof err).to.equal("string");
-    }
-  });
-
-  it("can rethrow null", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((_) => {
-      throw null;
-    }, this.port2);
-    try {
-      await thing();
-      throw "Should have thrown";
-    } catch (err) {
-      expect(err).to.not.equal("Should have thrown");
-      expect(err).to.equal(null);
-      expect(typeof err).to.equal("object");
-    }
-  });
-
-  it("can work with parameterized functions", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((a, b) => a + b, this.port2);
-    expect(await thing(1, 3)).to.equal(4);
-  });
-
-  it("can work with functions that return promises", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(
-      (_) => new Promise((resolve) => setTimeout((_) => resolve(4), 100)),
-      this.port2
-    );
-    expect(await thing()).to.equal(4);
-  });
-
-  it("can work with classes", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.method()).to.equal(4);
-  });
-
-  it("can pass parameters to class constructor", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing(23);
-    expect(await instance.counter).to.equal(23);
-  });
-
-  it("can access a class in an object", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose({ SampleClass }, this.port2);
-    const instance = await new thing.SampleClass();
-    expect(await instance.method()).to.equal(4);
-  });
-
-  it("can work with class instance properties", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance._counter).to.equal(1);
-  });
-
-  it("can set class instance properties", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance._counter).to.equal(1);
-    await (instance._counter = 4);
-    expect(await instance._counter).to.equal(4);
-  });
-
-  it("can work with class instance methods", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.counter).to.equal(1);
-    await instance.increaseCounter();
-    expect(await instance.counter).to.equal(2);
-  });
-
-  it("can handle throwing class instance methods", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    return instance
-      .throwsAnError()
-      .then((_) => Promise.reject())
-      .catch((err) => {});
-  });
-
-  it("can work with class instance methods multiple times", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.counter).to.equal(1);
-    await instance.increaseCounter();
-    await instance.increaseCounter(5);
-    expect(await instance.counter).to.equal(7);
-  });
-
-  it("can work with class instance methods that return promises", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.promiseFunc()).to.equal(4);
-  });
-
-  it("can work with class instance properties that are promises", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance._promise).to.equal(4);
-  });
-
-  it("can work with class instance getters that are promises", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.promise).to.equal(4);
-  });
-
-  it("can work with static class properties", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    expect(await thing.SOME_NUMBER).to.equal(4);
-  });
-
-  it("can work with static class methods", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    expect(await thing.ADD(1, 3)).to.equal(4);
-  });
-
-  it("can work with bound class instance methods", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.counter).to.equal(1);
-    const method = instance.increaseCounter.bind(instance);
-    await method();
-    expect(await instance.counter).to.equal(2);
-  });
-
-  it("can work with class instance getters", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance.counter).to.equal(1);
-    await instance.increaseCounter();
-    expect(await instance.counter).to.equal(2);
-  });
-
-  it("can work with class instance setters", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    expect(await instance._counter).to.equal(1);
-    await (instance.counter = 4);
-    expect(await instance._counter).to.equal(4);
-  });
-
-  const hasBroadcastChannel = (_) => "BroadcastChannel" in self;
-  guardedIt(hasBroadcastChannel)(
-    "will work with BroadcastChannel",
-    async function () {
-      const b1 = new BroadcastChannel("comlink_bc_test");
-      const b2 = new BroadcastChannel("comlink_bc_test");
-      const thing = Comlink.wrap(b1);
-      Comlink.expose((b) => 40 + b, b2);
-      expect(await thing(2)).to.equal(42);
-    }
-  );
-
-  // Buffer transfers seem to have regressed in Safari 11.1, it’s fixed in 11.2.
-  const isNotSafari11_1 = (_) =>
-    !/11\.1(\.[0-9]+)? Safari/.test(navigator.userAgent);
-  guardedIt(isNotSafari11_1)("will transfer buffers", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((b) => b.byteLength, this.port2);
-    const buffer = new Uint8Array([1, 2, 3]).buffer;
-    expect(await thing(Comlink.transfer(buffer, [buffer]))).to.equal(3);
-    expect(buffer.byteLength).to.equal(0);
-  });
-
-  guardedIt(isNotSafari11_1)("will copy TypedArrays", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((b) => b, this.port2);
-    const array = new Uint8Array([1, 2, 3]);
-    const receive = await thing(array);
-    expect(array).to.not.equal(receive);
-    expect(array.byteLength).to.equal(receive.byteLength);
-    expect([...array]).to.deep.equal([...receive]);
-  });
-
-  guardedIt(isNotSafari11_1)("will copy nested TypedArrays", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((b) => b, this.port2);
-    const array = new Uint8Array([1, 2, 3]);
-    const receive = await thing({
-      v: 1,
-      array,
-    });
-    expect(array).to.not.equal(receive.array);
-    expect(array.byteLength).to.equal(receive.array.byteLength);
-    expect([...array]).to.deep.equal([...receive.array]);
-  });
-
-  guardedIt(isNotSafari11_1)(
-    "will transfer deeply nested buffers",
-    async function () {
-      const thing = Comlink.wrap(this.port1);
-      Comlink.expose((a) => a.b.c.d.byteLength, this.port2);
-      const buffer = new Uint8Array([1, 2, 3]).buffer;
-      expect(
-        await thing(Comlink.transfer({ b: { c: { d: buffer } } }, [buffer]))
-      ).to.equal(3);
-      expect(buffer.byteLength).to.equal(0);
-    }
-  );
-
-  it("will transfer a message port", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose((a) => a.postMessage("ohai"), this.port2);
-    const { port1, port2 } = new MessageChannel();
-    await thing(Comlink.transfer(port2, [port2]));
-    return new Promise((resolve) => {
-      port1.onmessage = (event) => {
-        expect(event.data).to.equal("ohai");
-        resolve();
-      };
-    });
-  });
-
-  it("will wrap marked return values", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(
-      (_) =>
-        Comlink.proxy({
-          counter: 0,
-          inc() {
-            this.counter += 1;
-          },
-        }),
-      this.port2
-    );
-    const obj = await thing();
-    expect(await obj.counter).to.equal(0);
-    await obj.inc();
-    expect(await obj.counter).to.equal(1);
-  });
-
-  it("will wrap marked return values from class instance methods", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    const obj = await instance.proxyFunc();
-    expect(await obj.counter).to.equal(0);
-    await obj.inc();
-    expect(await obj.counter).to.equal(1);
-  });
-
-  it("will wrap marked parameter values", async function () {
-    const thing = Comlink.wrap(this.port1);
-    const local = {
-      counter: 0,
-      inc() {
-        this.counter++;
-      },
-    };
-    Comlink.expose(async function (f) {
-      await f.inc();
-    }, this.port2);
-    expect(local.counter).to.equal(0);
-    await thing(Comlink.proxy(local));
-    expect(await local.counter).to.equal(1);
-  });
-
-  it("will wrap marked assignments", function (done) {
-    const thing = Comlink.wrap(this.port1);
-    const obj = {
-      onready: null,
-      call() {
-        this.onready();
-      },
-    };
-    Comlink.expose(obj, this.port2);
-
-    thing.onready = Comlink.proxy(() => done());
-    thing.call();
-  });
-
-  it("will wrap marked parameter values, simple function", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(async function (f) {
-      await f();
-    }, this.port2);
-    // Weird code because Mocha
-    await new Promise(async (resolve) => {
-      thing(Comlink.proxy((_) => resolve()));
-    });
-  });
-
-  it("will wrap multiple marked parameter values, simple function", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(async function (f1, f2, f3) {
-      return (await f1()) + (await f2()) + (await f3());
-    }, this.port2);
-    // Weird code because Mocha
-    expect(
-      await thing(
-        Comlink.proxy((_) => 1),
-        Comlink.proxy((_) => 2),
-        Comlink.proxy((_) => 3)
-      )
-    ).to.equal(6);
-  });
-
-  xit("will proxy deeply nested values", async function () {
-    const thing = Comlink.wrap(this.port1);
-    const obj = {
-      a: {
-        v: 4,
-      },
-      b: Comlink.proxy({
-        v: 5,
-      }),
-    };
-    Comlink.expose(obj, this.port2);
-
-    const a = await thing.a;
-    const b = await thing.b;
-    expect(await a.v).to.equal(4);
-    expect(await b.v).to.equal(5);
-    await (a.v = 8);
-    await (b.v = 9);
-    expect(await thing.a.v).to.equal(4);
-    expect(await thing.b.v).to.equal(9);
-  });
-
-  it("will handle undefined parameters", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose({ f: (_) => 4 }, this.port2);
-    expect(await thing.f(undefined)).to.equal(4);
-  });
-
-  it("can handle destructuring", async function () {
-    Comlink.expose(
-      {
-        a: 4,
-        get b() {
-          return 5;
-        },
-        c() {
-          return 6;
-        },
-      },
-      this.port2
-    );
-    const { a, b, c } = Comlink.wrap(this.port1);
-    expect(await a).to.equal(4);
-    expect(await b).to.equal(5);
-    expect(await c()).to.equal(6);
-  });
-
-  it("lets users define transfer handlers", function (done) {
-    Comlink.transferHandlers.set("event", {
-      canHandle(obj) {
-        return obj instanceof Event;
-      },
-      serialize(obj) {
-        return [obj.data, []];
-      },
-      deserialize(data) {
-        return new MessageEvent("message", { data });
-      },
-    });
-
-    Comlink.expose((ev) => {
-      expect(ev).to.be.an.instanceOf(Event);
-      expect(ev.data).to.deep.equal({ a: 1 });
-      done();
-    }, this.port1);
-    const thing = Comlink.wrap(this.port2);
-
-    const { port1, port2 } = new MessageChannel();
-    port1.addEventListener("message", thing.bind(this));
-    port1.start();
-    port2.postMessage({ a: 1 });
-  });
-
-  it("can tunnels a new endpoint with createEndpoint", async function () {
-    Comlink.expose(
-      {
-        a: 4,
-        c() {
-          return 5;
-        },
-      },
-      this.port2
-    );
-    const proxy = Comlink.wrap(this.port1);
-    const otherEp = await proxy[Comlink.createEndpoint]();
-    const otherProxy = Comlink.wrap(otherEp);
-    expect(await otherProxy.a).to.equal(4);
-    expect(await proxy.a).to.equal(4);
-    expect(await otherProxy.c()).to.equal(5);
-    expect(await proxy.c()).to.equal(5);
-  });
-
-  it("released proxy should no longer be useable and throw an exception", async function () {
-    const thing = Comlink.wrap(this.port1);
-    Comlink.expose(SampleClass, this.port2);
-    const instance = await new thing();
-    await instance[Comlink.releaseProxy]();
-    expect(() => instance.method()).to.throw();
-  });
-
-  it("can proxy with a given target", async function () {
-    const thing = Comlink.wrap(this.port1, { value: {} });
-    Comlink.expose({ value: 4 }, this.port2);
-    expect(await thing.value).to.equal(4);
-  });
-});
-
-function guardedIt(f) {
-  return f() ? it : xit;
-}

package/template/node_modules/comlink/tests/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": ["./**/*.ts"]
-}

package/template/node_modules/comlink/tests/two-way-iframe.comlink.test.js

@@ -1,40 +0,0 @@
-/**
- * Copyright 2017 Google Inc. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import * as Comlink from "/base/dist/esm/comlink.mjs";
-
-describe("Comlink across iframes", function () {
-  beforeEach(function () {
-    this.ifr = document.createElement("iframe");
-    this.ifr.sandbox.add("allow-scripts", "allow-same-origin");
-    this.ifr.src = "/base/tests/fixtures/two-way-iframe.html";
-    document.body.appendChild(this.ifr);
-    return new Promise((resolve) => (this.ifr.onload = resolve));
-  });
-
-  afterEach(function () {
-    this.ifr.remove();
-  });
-
-  it("can communicate both ways", async function () {
-    let called = false;
-    const iframe = Comlink.windowEndpoint(this.ifr.contentWindow);
-    Comlink.expose((a) => {
-      called = true;
-      return ++a;
-    }, iframe);
-    const proxy = Comlink.wrap(iframe);
-    expect(await proxy(1, 3)).to.equal(5);
-    expect(called).to.equal(true);
-  });
-});