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

package/template/node_modules/comlink/tests/type-checks.ts

@@ -0,0 +1,371 @@
+import { assert, Has, NotHas, IsAny, IsExact } from "conditional-type-checks";
+
+import * as Comlink from "../src/comlink.js";
+
+async function closureSoICanUseAwait() {
+  {
+    function simpleNumberFunction() {
+      return 4;
+    }
+
+    const proxy = Comlink.wrap<typeof simpleNumberFunction>(0 as any);
+    assert<IsAny<typeof proxy>>(false);
+    const v = proxy();
+    assert<Has<typeof v, Promise<number>>>(true);
+  }
+
+  {
+    function simpleObjectFunction() {
+      return { a: 3 };
+    }
+
+    const proxy = Comlink.wrap<typeof simpleObjectFunction>(0 as any);
+    const v = await proxy();
+    assert<Has<typeof v, { a: number }>>(true);
+  }
+
+  {
+    async function simpleAsyncFunction() {
+      return { a: 3 };
+    }
+
+    const proxy = Comlink.wrap<typeof simpleAsyncFunction>(0 as any);
+    const v = await proxy();
+    assert<Has<typeof v, { a: number }>>(true);
+  }
+
+  {
+    function functionWithProxy() {
+      return Comlink.proxy({ a: 3 });
+    }
+
+    const proxy = Comlink.wrap<typeof functionWithProxy>(0 as any);
+    const subproxy = await proxy();
+    const prop = subproxy.a;
+    assert<Has<typeof prop, Promise<number>>>(true);
+  }
+
+  {
+    class X {
+      static staticFunc() {
+        return 4;
+      }
+      private f = 4;
+      public g = 9;
+      sayHi() {
+        return "hi";
+      }
+    }
+
+    const proxy = Comlink.wrap<typeof X>(0 as any);
+    assert<Has<typeof proxy, { staticFunc: () => Promise<number> }>>(true);
+    const instance = await new proxy();
+    assert<Has<typeof instance, { sayHi: () => Promise<string> }>>(true);
+    assert<Has<typeof instance, { g: Promise<number> }>>(true);
+    assert<NotHas<typeof instance, { f: Promise<number> }>>(true);
+    assert<IsAny<typeof instance>>(false);
+  }
+
+  {
+    const x = {
+      a: 4,
+      b() {
+        return 9;
+      },
+      c: {
+        d: 3,
+      },
+    };
+
+    const proxy = Comlink.wrap<typeof x>(0 as any);
+    assert<IsAny<typeof proxy>>(false);
+    const a = proxy.a;
+    assert<Has<typeof a, Promise<number>>>(true);
+    assert<IsAny<typeof a>>(false);
+    const b = proxy.b;
+    assert<Has<typeof b, () => Promise<number>>>(true);
+    assert<IsAny<typeof b>>(false);
+    const subproxy = proxy.c;
+    assert<Has<typeof subproxy, Promise<{ d: number }>>>(true);
+    assert<IsAny<typeof subproxy>>(false);
+    const copy = await proxy.c;
+    assert<Has<typeof copy, { d: number }>>(true);
+  }
+
+  {
+    Comlink.wrap(new MessageChannel().port1);
+    Comlink.expose({}, new MessageChannel().port2);
+
+    interface Baz {
+      baz: number;
+      method(): number;
+    }
+
+    class Foo {
+      constructor(cParam: string) {
+        const self = this;
+        assert<IsExact<typeof self.proxyProp, Bar & Comlink.ProxyMarked>>(true);
+      }
+      prop1: string = "abc";
+      proxyProp = Comlink.proxy(new Bar());
+      methodWithTupleParams(...args: [string] | [number, string]): number {
+        return 123;
+      }
+      methodWithProxiedReturnValue(): Baz & Comlink.ProxyMarked {
+        return Comlink.proxy({ baz: 123, method: () => 123 });
+      }
+      methodWithProxyParameter(param: Baz & Comlink.ProxyMarked): void {}
+    }
+
+    class Bar {
+      prop2: string | number = "abc";
+      method(param: string): number {
+        return 123;
+      }
+      methodWithProxiedReturnValue(): Baz & Comlink.ProxyMarked {
+        return Comlink.proxy({ baz: 123, method: () => 123 });
+      }
+    }
+    const proxy = Comlink.wrap<Foo>(Comlink.windowEndpoint(self));
+    assert<IsExact<typeof proxy, Comlink.Remote<Foo>>>(true);
+
+    proxy[Comlink.releaseProxy]();
+    const endp = proxy[Comlink.createEndpoint]();
+    assert<IsExact<typeof endp, Promise<MessagePort>>>(true);
+
+    assert<IsAny<typeof proxy.prop1>>(false);
+    assert<Has<typeof proxy.prop1, Promise<string>>>(true);
+
+    const r1 = proxy.methodWithTupleParams(123, "abc");
+    assert<IsExact<typeof r1, Promise<number>>>(true);
+
+    const r2 = proxy.methodWithTupleParams("abc");
+    assert<IsExact<typeof r2, Promise<number>>>(true);
+
+    assert<
+      IsExact<typeof proxy.proxyProp, Comlink.Remote<Bar & Comlink.ProxyMarked>>
+    >(true);
+
+    assert<IsAny<typeof proxy.proxyProp.prop2>>(false);
+    assert<Has<typeof proxy.proxyProp.prop2, Promise<string>>>(true);
+    assert<Has<typeof proxy.proxyProp.prop2, Promise<number>>>(true);
+
+    const r3 = proxy.proxyProp.method("param");
+    assert<IsAny<typeof r3>>(false);
+    assert<Has<typeof r3, Promise<number>>>(true);
+
+    // @ts-expect-error
+    proxy.proxyProp.method(123);
+
+    // @ts-expect-error
+    proxy.proxyProp.method();
+
+    const r4 = proxy.methodWithProxiedReturnValue();
+    assert<IsAny<typeof r4>>(false);
+    assert<
+      IsExact<typeof r4, Promise<Comlink.Remote<Baz & Comlink.ProxyMarked>>>
+    >(true);
+
+    const r5 = proxy.proxyProp.methodWithProxiedReturnValue();
+    assert<
+      IsExact<typeof r5, Promise<Comlink.Remote<Baz & Comlink.ProxyMarked>>>
+    >(true);
+
+    const r6 = (await proxy.methodWithProxiedReturnValue()).baz;
+    assert<IsAny<typeof r6>>(false);
+    assert<Has<typeof r6, Promise<number>>>(true);
+
+    const r7 = (await proxy.methodWithProxiedReturnValue()).method();
+    assert<IsAny<typeof r7>>(false);
+    assert<Has<typeof r7, Promise<number>>>(true);
+
+    const ProxiedFooClass = Comlink.wrap<typeof Foo>(
+      Comlink.windowEndpoint(self)
+    );
+    const inst1 = await new ProxiedFooClass("test");
+    assert<IsExact<typeof inst1, Comlink.Remote<Foo>>>(true);
+    inst1[Comlink.releaseProxy]();
+    inst1[Comlink.createEndpoint]();
+
+    // @ts-expect-error
+    await new ProxiedFooClass(123);
+
+    // @ts-expect-error
+    await new ProxiedFooClass();
+
+    //
+    // Tests for advanced proxy use cases
+    //
+
+    // Type round trips
+    // This tests that Local is the exact inverse of Remote for objects:
+    assert<
+      IsExact<
+        Comlink.Local<Comlink.Remote<Comlink.ProxyMarked>>,
+        Comlink.ProxyMarked
+      >
+    >(true);
+    // This tests that Local is the exact inverse of Remote for functions, with one difference:
+    // The local version of a remote function can be either implemented as a sync or async function,
+    // because Remote<T> always makes the function async.
+    assert<
+      IsExact<
+        Comlink.Local<Comlink.Remote<(a: number) => string>>,
+        (a: number) => string | Promise<string>
+      >
+    >(true);
+
+    interface Subscriber<T> {
+      closed?: boolean;
+      next?: (value: T) => void;
+    }
+    interface Unsubscribable {
+      unsubscribe(): void;
+    }
+    /** A Subscribable that can get proxied by Comlink */
+    interface ProxyableSubscribable<T> extends Comlink.ProxyMarked {
+      subscribe(
+        subscriber: Comlink.Remote<Subscriber<T> & Comlink.ProxyMarked>
+      ): Unsubscribable & Comlink.ProxyMarked;
+    }
+
+    /** Simple parameter object that gets cloned (not proxied) */
+    interface Params {
+      textDocument: string;
+    }
+
+    class Registry {
+      async registerProvider(
+        provider: Comlink.Remote<
+          ((params: Params) => ProxyableSubscribable<string>) &
+            Comlink.ProxyMarked
+        >
+      ) {
+        const resultPromise = provider({ textDocument: "foo" });
+        assert<
+          IsExact<
+            typeof resultPromise,
+            Promise<Comlink.Remote<ProxyableSubscribable<string>>>
+          >
+        >(true);
+        const result = await resultPromise;
+
+        const subscriptionPromise = result.subscribe({
+          [Comlink.proxyMarker]: true,
+          next: (value) => {
+            assert<IsExact<typeof value, string>>(true);
+          },
+        });
+        assert<
+          IsExact<
+            typeof subscriptionPromise,
+            Promise<Comlink.Remote<Unsubscribable & Comlink.ProxyMarked>>
+          >
+        >(true);
+        const subscriber = Comlink.proxy({
+          next: (value: string) => console.log(value),
+        });
+        result.subscribe(subscriber);
+
+        const r1 = (await subscriptionPromise).unsubscribe();
+        assert<IsExact<typeof r1, Promise<void>>>(true);
+      }
+    }
+    const proxy2 = Comlink.wrap<Registry>(Comlink.windowEndpoint(self));
+
+    proxy2.registerProvider(
+      // Synchronous callback
+      Comlink.proxy(({ textDocument }: Params) => {
+        const subscribable = Comlink.proxy({
+          subscribe(
+            subscriber: Comlink.Remote<Subscriber<string> & Comlink.ProxyMarked>
+          ): Unsubscribable & Comlink.ProxyMarked {
+            // Important to test here is that union types (such as Function | undefined) distribute properly
+            // when wrapped in Promises/proxied
+
+            assert<IsAny<typeof subscriber.closed>>(false);
+            assert<
+              IsExact<
+                typeof subscriber.closed,
+                Promise<true> | Promise<false> | Promise<undefined> | undefined
+              >
+            >(true);
+
+            assert<IsAny<typeof subscriber.next>>(false);
+            assert<
+              IsExact<
+                typeof subscriber.next,
+                | Comlink.Remote<(value: string) => void>
+                | Promise<undefined>
+                | undefined
+              >
+            >(true);
+
+            // @ts-expect-error
+            subscriber.next();
+
+            if (subscriber.next) {
+              // Only checking for presence is not enough, since it could be a Promise
+              // @ts-expect-error
+              subscriber.next();
+            }
+
+            if (typeof subscriber.next === "function") {
+              subscriber.next("abc");
+            }
+
+            return Comlink.proxy({ unsubscribe() {} });
+          },
+        });
+        assert<Has<typeof subscribable, Comlink.ProxyMarked>>(true);
+        return subscribable;
+      })
+    );
+    proxy2.registerProvider(
+      // Async callback
+      Comlink.proxy(async ({ textDocument }: Params) => {
+        const subscribable = Comlink.proxy({
+          subscribe(
+            subscriber: Comlink.Remote<Subscriber<string> & Comlink.ProxyMarked>
+          ): Unsubscribable & Comlink.ProxyMarked {
+            assert<IsAny<typeof subscriber.next>>(false);
+            assert<
+              IsExact<
+                typeof subscriber.next,
+                | Comlink.Remote<(value: string) => void>
+                | Promise<undefined>
+                | undefined
+              >
+            >(true);
+
+            // Only checking for presence is not enough, since it could be a Promise
+            if (typeof subscriber.next === "function") {
+              subscriber.next("abc");
+            }
+            return Comlink.proxy({ unsubscribe() {} });
+          },
+        });
+        return subscribable;
+      })
+    );
+  }
+
+  // Transfer handlers
+  {
+    const urlTransferHandler: Comlink.TransferHandler<URL, string> = {
+      canHandle: (val): val is URL => {
+        assert<IsExact<typeof val, unknown>>(true);
+        return val instanceof URL;
+      },
+      serialize: (url) => {
+        assert<IsExact<typeof url, URL>>(true);
+        return [url.href, []];
+      },
+      deserialize: (str) => {
+        assert<IsExact<typeof str, string>>(true);
+        return new URL(str);
+      },
+    };
+    Comlink.transferHandlers.set("URL", urlTransferHandler);
+  }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * 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 workers", function () {
+  beforeEach(function () {
+    this.worker = new Worker("/base/tests/fixtures/worker.js");
+  });
+
+  afterEach(function () {
+    this.worker.terminate();
+  });
+
+  it("can communicate", async function () {
+    const proxy = Comlink.wrap(this.worker);
+    expect(await proxy(1, 3)).to.equal(4);
+  });
+
+  it("can tunnels a new endpoint with createEndpoint", async function () {
+    const proxy = Comlink.wrap(this.worker);
+    const otherEp = await proxy[Comlink.createEndpoint]();
+    const otherProxy = Comlink.wrap(otherEp);
+    expect(await otherProxy(20, 1)).to.equal(21);
+  });
+});

package/template/node_modules/comlink/tsconfig.json

@@ -0,0 +1,58 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es2015" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', or 'ESNEXT'. */,
+    "module": "esnext" /* Specify module code generation: 'none', commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+    "lib": [
+      "esnext",
+      "dom"
+    ] /* Specify library files to be included in the compilation:  */,
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "removeComments": false,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+
+    /* Source Map Options */
+    // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+  },
+  "include": ["src/**/*.ts"]
+}

package/template/node_modules/ts-custom-error/CHANGELOG.md

@@ -0,0 +1,114 @@
+# [3.2.0](https://github.com/adriengibrat/ts-custom-error/compare/v3.1.1...v3.2.0) (2020-08-24)
+
+
+### Features
+
+* **name:** Allow to redefine error name property ([94efde0](https://github.com/adriengibrat/ts-custom-error/commit/94efde0a70b62eea191bc9ff204b43101f367da8))
+
+## [3.1.1](https://github.com/adriengibrat/ts-custom-error/compare/v3.1.0...v3.1.1) (2019-07-03)
+
+
+### Bug Fixes
+
+* **package:** Remove codeclimate-reporter binary from npm package ([52a6db9](https://github.com/adriengibrat/ts-custom-error/commit/52a6db9)), closes [#32](https://github.com/adriengibrat/ts-custom-error/issues/32)
+
+# [3.1.0](https://github.com/adriengibrat/ts-custom-error/compare/v3.0.0...v3.1.0) (2019-05-17)
+
+
+### Features
+
+* **log:** Behave like native Error when using console.log ([f884c51](https://github.com/adriengibrat/ts-custom-error/commit/f884c51)), closes [#30](https://github.com/adriengibrat/ts-custom-error/issues/30)
+
+# [3.0.0](https://github.com/adriengibrat/ts-custom-error/compare/v2.2.2...v3.0.0) (2019-03-15)
+
+
+### chore
+
+* **licence:** Change licence to MIT instead of WTFPL ([7ff194c](https://github.com/adriengibrat/ts-custom-error/commit/7ff194c)), closes [#27](https://github.com/adriengibrat/ts-custom-error/issues/27)
+
+
+### BREAKING CHANGES
+
+* **licence:** Change licence to MIT!
+
+## [2.2.2](https://github.com/adriengibrat/ts-custom-error/compare/v2.2.1...v2.2.2) (2018-12-29)
+
+
+### Bug Fixes
+
+* **release:** Fix umd minification issue, add typescript definitions for all bundles formats ([a091837](https://github.com/adriengibrat/ts-custom-error/commit/a091837))
+
+<a name="2.2.1"></a>
+## [2.2.1](https://github.com/adriengibrat/ts-custom-error/compare/v2.2.0...v2.2.1) (2018-04-04)
+
+
+### Bug Fixes
+
+* Fix latest travis deploy fail status ([0b18352](https://github.com/adriengibrat/ts-custom-error/commit/0b18352))
+
+<a name="2.2.0"></a>
+# [2.2.0](https://github.com/adriengibrat/ts-custom-error/compare/v2.1.0...v2.2.0) (2018-04-04)
+
+
+### Features
+
+* Add custom error name support ([7791153](https://github.com/adriengibrat/ts-custom-error/commit/7791153))
+
+<a name="2.1.0"></a>
+# [2.1.0](https://github.com/adriengibrat/ts-custom-error/compare/v2.0.0...v2.1.0) (2018-03-24)
+
+
+### Features
+
+* Improve factory typings ([dc1eed6](https://github.com/adriengibrat/ts-custom-error/commit/dc1eed6))
+
+
+
+<a name="2.0.0"></a>
+# [2.0.0](https://github.com/adriengibrat/ts-custom-error/compare/v1.0.1...v2.0.0) (2018-03-16)
+
+
+### Code Refactoring
+
+* Change factory export name to customErrorFactory ([e8f51a0](https://github.com/adriengibrat/ts-custom-error/commit/e8f51a0))
+
+
+### Features
+
+* Export factory Typescript Interfaces ([d03b476](https://github.com/adriengibrat/ts-custom-error/commit/d03b476))
+
+
+### BREAKING CHANGES
+
+* the factory export name changed from `factory `to more expliit `customErrorFactory`
+
+
+
+<a name="1.0.1"></a>
+## [1.0.1](https://github.com/adriengibrat/ts-custom-error/compare/v1.0.0...v1.0.1) (2018-03-12)
+
+
+### Bug Fixes
+
+* Expose constructor in prototype when using factory ([387cc8d](https://github.com/adriengibrat/ts-custom-error/commit/387cc8d))
+
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/adriengibrat/ts-custom-error/compare/v0.0.2...v1.0.0) (2018-03-12)
+
+
+### Code Refactoring
+
+* Rewrite factory to be Higher order function ([720940c](https://github.com/adriengibrat/ts-custom-error/commit/720940c))
+
+### BREAKING CHANGES
+
+* The factory now accept a function as first parameter where previously it used an error name and a list of property keys
+
+
+
+<a name="0.0.2"></a>
+## 0.0.2 (2018-03-12)
+
+First release

package/template/node_modules/ts-custom-error/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2019 Adrien Gibrat https://github.com/adriengibrat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.