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

package/template/node_modules/comlink/package.json

@@ -1,84 +0,0 @@
-{
-  "_from": "comlink",
-  "_id": "comlink@4.3.1",
-  "_inBundle": false,
-  "_integrity": "sha512-+YbhUdNrpBZggBAHWcgQMLPLH1KDF3wJpeqrCKieWQ8RL7atmgsgTQko1XEBK6PsecfopWNntopJ+ByYG1lRaA==",
-  "_location": "/comlink",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "tag",
-    "registry": true,
-    "raw": "comlink",
-    "name": "comlink",
-    "escapedName": "comlink",
-    "rawSpec": "",
-    "saveSpec": null,
-    "fetchSpec": "latest"
-  },
-  "_requiredBy": [
-    "#USER",
-    "/"
-  ],
-  "_resolved": "https://registry.npmjs.org/comlink/-/comlink-4.3.1.tgz",
-  "_shasum": "0c6b9d69bcd293715c907c33fe8fc45aecad13c5",
-  "_spec": "comlink",
-  "_where": "/Users/fengkx/lowcode/cloudbase-framework-plugin-low-code/packages/framework-plugin-low-code/template",
-  "author": {
-    "name": "Surma",
-    "email": "surma@google.com"
-  },
-  "bugs": {
-    "url": "https://github.com/GoogleChromeLabs/comlink/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {},
-  "deprecated": false,
-  "description": "Comlink makes WebWorkers enjoyable",
-  "devDependencies": {
-    "chai": "4.2.0",
-    "conditional-type-checks": "1.0.5",
-    "husky": "4.2.5",
-    "karma": "^5.0.9",
-    "karma-chai": "0.1.0",
-    "karma-chrome-launcher": "3.1.0",
-    "karma-detect-browsers": "2.3.3",
-    "karma-firefox-launcher": "1.3.0",
-    "karma-mocha": "^2.0.1",
-    "karma-safari-launcher": "1.0.0",
-    "karma-safaritechpreview-launcher": "2.0.2",
-    "mocha": "^7.2.0",
-    "prettier": "2.0.5",
-    "rimraf": "3.0.2",
-    "rollup": "^2.11.2",
-    "rollup-plugin-terser": "^6.1.0",
-    "rollup-plugin-typescript2": "^0.27.1",
-    "typescript": "^3.9.3"
-  },
-  "homepage": "https://github.com/GoogleChromeLabs/comlink#readme",
-  "husky": {
-    "hooks": {
-      "pre-commit": "npm test"
-    }
-  },
-  "license": "Apache-2.0",
-  "main": "dist/umd/comlink.js",
-  "module": "dist/esm/comlink.mjs",
-  "name": "comlink",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/GoogleChromeLabs/comlink.git"
-  },
-  "scripts": {
-    "build": "rollup -c",
-    "fmt": "prettier --write './*.{mjs,js,ts,md,json,html}' './{src,docs,tests}/{,**/}*.{mjs,js,ts,md,json,html}'",
-    "fmt_test": "test $(prettier -l './*.{mjs,js,ts,md,json,html}' './{src,docs,tests}/{**/,}*.{mjs,js,ts,md,json,html}' | wc -l) -eq 0",
-    "test": "npm run fmt_test && npm run build && npm run test:types && npm run test:unit",
-    "test:types": "tsc -p ./tests/tsconfig.json",
-    "test:types:watch": "npm run test:types -- --watch",
-    "test:unit": "karma start",
-    "watchtest": "CHROME_ONLY=1 karma start --no-single-run"
-  },
-  "sideEffects": false,
-  "types": "dist/umd/comlink.d.ts",
-  "version": "4.3.1"
-}

package/template/node_modules/comlink/renovate.json

@@ -1,4 +0,0 @@
-{
-  "extends": [":library"],
-  "assignees": ["surma"]
-}

package/template/node_modules/comlink/rollup.config.js

@@ -1,51 +0,0 @@
-import typescript from "rollup-plugin-typescript2";
-import { terser } from "rollup-plugin-terser";
-
-function config({ format, minify, input, ext = "js" }) {
-  const dir = `dist/${format}/`;
-  const minifierSuffix = minify ? ".min" : "";
-  return {
-    input: `./src/${input}.ts`,
-    output: {
-      name: "Comlink",
-      file: `${dir}/${input}${minifierSuffix}.${ext}`,
-      format,
-      sourcemap: true,
-    },
-    plugins: [
-      typescript({
-        clean: true,
-        typescript: require("typescript"),
-        tsconfigOverride: {
-          compilerOptions: {
-            sourceMap: true,
-          },
-          // Don’t ask. Without this, the typescript plugin is convinced
-          // to create subfolders and misplace the .d.ts files.
-          files: ["./src/comlink.ts", "./src/protocol.ts"],
-        },
-      }),
-      minify
-        ? terser({
-            compress: true,
-            mangle: true,
-          })
-        : undefined,
-    ].filter(Boolean),
-  };
-}
-
-require("rimraf").sync("dist");
-
-export default [
-  { input: "comlink", format: "esm", minify: false, ext: "mjs" },
-  { input: "comlink", format: "esm", minify: true, ext: "mjs" },
-  { input: "comlink", format: "esm", minify: false },
-  { input: "comlink", format: "esm", minify: true },
-  { input: "comlink", format: "umd", minify: false },
-  { input: "comlink", format: "umd", minify: true },
-  { input: "node-adapter", format: "esm", minify: false, ext: "mjs" },
-  { input: "node-adapter", format: "esm", minify: true, ext: "mjs" },
-  { input: "node-adapter", format: "umd", minify: false },
-  { input: "node-adapter", format: "umd", minify: true },
-].map(config);

package/template/node_modules/comlink/src/comlink.ts

@@ -1,553 +0,0 @@
-/**
- * Copyright 2019 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 {
-  Endpoint,
-  EventSource,
-  Message,
-  MessageType,
-  PostMessageWithOrigin,
-  WireValue,
-  WireValueType,
-} from "./protocol";
-export { Endpoint };
-
-export const proxyMarker = Symbol("Comlink.proxy");
-export const createEndpoint = Symbol("Comlink.endpoint");
-export const releaseProxy = Symbol("Comlink.releaseProxy");
-
-const throwMarker = Symbol("Comlink.thrown");
-
-/**
- * Interface of values that were marked to be proxied with `comlink.proxy()`.
- * Can also be implemented by classes.
- */
-export interface ProxyMarked {
-  [proxyMarker]: true;
-}
-
-/**
- * Takes a type and wraps it in a Promise, if it not already is one.
- * This is to avoid `Promise<Promise<T>>`.
- *
- * This is the inverse of `Unpromisify<T>`.
- */
-type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
-/**
- * Takes a type that may be Promise and unwraps the Promise type.
- * If `P` is not a Promise, it returns `P`.
- *
- * This is the inverse of `Promisify<T>`.
- */
-type Unpromisify<P> = P extends Promise<infer T> ? T : P;
-
-/**
- * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
- *
- * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
- * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
- */
-type RemoteProperty<T> =
-  // If the value is a method, comlink will proxy it automatically.
-  // Objects are only proxied if they are marked to be proxied.
-  // Otherwise, the property is converted to a Promise that resolves the cloned value.
-  T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
-
-/**
- * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
- * argument) and returns the type that the local thread has to supply.
- *
- * This is the inverse of `RemoteProperty<T>`.
- *
- * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
- * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
- */
-type LocalProperty<T> = T extends Function | ProxyMarked
-  ? Local<T>
-  : Unpromisify<T>;
-
-/**
- * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
- */
-export type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
-/**
- * Inverse of `ProxyOrClone<T>`.
- */
-export type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked>
-  ? Local<T>
-  : T;
-
-/**
- * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
- * when proxied with `Comlink.proxy()`.
- *
- * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
- *
- * @template T The raw type of a remote object as seen in the other thread.
- */
-export type RemoteObject<T> = { [P in keyof T]: RemoteProperty<T[P]> };
-/**
- * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
- * argument) and returns the type that the local thread has to supply.
- *
- * This does not handle call signatures, which is handled by the more general `Local<T>` type.
- *
- * This is the inverse of `RemoteObject<T>`.
- *
- * @template T The type of a proxied object.
- */
-export type LocalObject<T> = { [P in keyof T]: LocalProperty<T[P]> };
-
-/**
- * Additional special comlink methods available on each proxy returned by `Comlink.wrap()`.
- */
-export interface ProxyMethods {
-  [createEndpoint]: () => Promise<MessagePort>;
-  [releaseProxy]: () => void;
-}
-
-/**
- * Takes the raw type of a remote object, function or class in the other thread and returns the type as it is visible to
- * the local thread from the proxy return value of `Comlink.wrap()` or `Comlink.proxy()`.
- */
-export type Remote<T> =
-  // Handle properties
-  RemoteObject<T> &
-    // Handle call signature (if present)
-    (T extends (...args: infer TArguments) => infer TReturn
-      ? (
-          ...args: { [I in keyof TArguments]: UnproxyOrClone<TArguments[I]> }
-        ) => Promisify<ProxyOrClone<Unpromisify<TReturn>>>
-      : unknown) &
-    // Handle construct signature (if present)
-    // The return of construct signatures is always proxied (whether marked or not)
-    (T extends { new (...args: infer TArguments): infer TInstance }
-      ? {
-          new (
-            ...args: {
-              [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
-            }
-          ): Promisify<Remote<TInstance>>;
-        }
-      : unknown) &
-    // Include additional special comlink methods available on the proxy.
-    ProxyMethods;
-
-/**
- * Expresses that a type can be either a sync or async.
- */
-type MaybePromise<T> = Promise<T> | T;
-
-/**
- * Takes the raw type of a remote object, function or class as a remote thread would see it through a proxy (e.g. when
- * passed in as a function argument) and returns the type the local thread has to supply.
- *
- * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
- */
-export type Local<T> =
-  // Omit the special proxy methods (they don't need to be supplied, comlink adds them)
-  Omit<LocalObject<T>, keyof ProxyMethods> &
-    // Handle call signatures (if present)
-    (T extends (...args: infer TArguments) => infer TReturn
-      ? (
-          ...args: { [I in keyof TArguments]: ProxyOrClone<TArguments[I]> }
-        ) => // The raw function could either be sync or async, but is always proxied automatically
-        MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>>
-      : unknown) &
-    // Handle construct signature (if present)
-    // The return of construct signatures is always proxied (whether marked or not)
-    (T extends { new (...args: infer TArguments): infer TInstance }
-      ? {
-          new (
-            ...args: {
-              [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
-            }
-          ): // The raw constructor could either be sync or async, but is always proxied automatically
-          MaybePromise<Local<Unpromisify<TInstance>>>;
-        }
-      : unknown);
-
-const isObject = (val: unknown): val is object =>
-  (typeof val === "object" && val !== null) || typeof val === "function";
-
-/**
- * Customizes the serialization of certain values as determined by `canHandle()`.
- *
- * @template T The input type being handled by this transfer handler.
- * @template S The serialized type sent over the wire.
- */
-export interface TransferHandler<T, S> {
-  /**
-   * Gets called for every value to determine whether this transfer handler
-   * should serialize the value, which includes checking that it is of the right
-   * type (but can perform checks beyond that as well).
-   */
-  canHandle(value: unknown): value is T;
-
-  /**
-   * Gets called with the value if `canHandle()` returned `true` to produce a
-   * value that can be sent in a message, consisting of structured-cloneable
-   * values and/or transferrable objects.
-   */
-  serialize(value: T): [S, Transferable[]];
-
-  /**
-   * Gets called to deserialize an incoming value that was serialized in the
-   * other thread with this transfer handler (known through the name it was
-   * registered under).
-   */
-  deserialize(value: S): T;
-}
-
-/**
- * Internal transfer handle to handle objects marked to proxy.
- */
-const proxyTransferHandler: TransferHandler<object, MessagePort> = {
-  canHandle: (val): val is ProxyMarked =>
-    isObject(val) && (val as ProxyMarked)[proxyMarker],
-  serialize(obj) {
-    const { port1, port2 } = new MessageChannel();
-    expose(obj, port1);
-    return [port2, [port2]];
-  },
-  deserialize(port) {
-    port.start();
-    return wrap(port);
-  },
-};
-
-interface ThrownValue {
-  [throwMarker]: unknown; // just needs to be present
-  value: unknown;
-}
-type SerializedThrownValue =
-  | { isError: true; value: Error }
-  | { isError: false; value: unknown };
-
-/**
- * Internal transfer handler to handle thrown exceptions.
- */
-const throwTransferHandler: TransferHandler<
-  ThrownValue,
-  SerializedThrownValue
-> = {
-  canHandle: (value): value is ThrownValue =>
-    isObject(value) && throwMarker in value,
-  serialize({ value }) {
-    let serialized: SerializedThrownValue;
-    if (value instanceof Error) {
-      serialized = {
-        isError: true,
-        value: {
-          message: value.message,
-          name: value.name,
-          stack: value.stack,
-        },
-      };
-    } else {
-      serialized = { isError: false, value };
-    }
-    return [serialized, []];
-  },
-  deserialize(serialized) {
-    if (serialized.isError) {
-      throw Object.assign(
-        new Error(serialized.value.message),
-        serialized.value
-      );
-    }
-    throw serialized.value;
-  },
-};
-
-/**
- * Allows customizing the serialization of certain values.
- */
-export const transferHandlers = new Map<
-  string,
-  TransferHandler<unknown, unknown>
->([
-  ["proxy", proxyTransferHandler],
-  ["throw", throwTransferHandler],
-]);
-
-export function expose(obj: any, ep: Endpoint = self as any) {
-  ep.addEventListener("message", function callback(ev: MessageEvent) {
-    if (!ev || !ev.data) {
-      return;
-    }
-    const { id, type, path } = {
-      path: [] as string[],
-      ...(ev.data as Message),
-    };
-    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-    let returnValue;
-    try {
-      const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
-      const rawValue = path.reduce((obj, prop) => obj[prop], obj);
-      switch (type) {
-        case MessageType.GET:
-          {
-            returnValue = rawValue;
-          }
-          break;
-        case MessageType.SET:
-          {
-            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-            returnValue = true;
-          }
-          break;
-        case MessageType.APPLY:
-          {
-            returnValue = rawValue.apply(parent, argumentList);
-          }
-          break;
-        case MessageType.CONSTRUCT:
-          {
-            const value = new rawValue(...argumentList);
-            returnValue = proxy(value);
-          }
-          break;
-        case MessageType.ENDPOINT:
-          {
-            const { port1, port2 } = new MessageChannel();
-            expose(obj, port2);
-            returnValue = transfer(port1, [port1]);
-          }
-          break;
-        case MessageType.RELEASE:
-          {
-            returnValue = undefined;
-          }
-          break;
-        default:
-          return;
-      }
-    } catch (value) {
-      returnValue = { value, [throwMarker]: 0 };
-    }
-    Promise.resolve(returnValue)
-      .catch((value) => {
-        return { value, [throwMarker]: 0 };
-      })
-      .then((returnValue) => {
-        const [wireValue, transferables] = toWireValue(returnValue);
-        ep.postMessage({ ...wireValue, id }, transferables);
-        if (type === MessageType.RELEASE) {
-          // detach and deactive after sending release response above.
-          ep.removeEventListener("message", callback as any);
-          closeEndPoint(ep);
-        }
-      });
-  } as any);
-  if (ep.start) {
-    ep.start();
-  }
-}
-
-function isMessagePort(endpoint: Endpoint): endpoint is MessagePort {
-  return endpoint.constructor.name === "MessagePort";
-}
-
-function closeEndPoint(endpoint: Endpoint) {
-  if (isMessagePort(endpoint)) endpoint.close();
-}
-
-export function wrap<T>(ep: Endpoint, target?: any): Remote<T> {
-  return createProxy<T>(ep, [], target) as any;
-}
-
-function throwIfProxyReleased(isReleased: boolean) {
-  if (isReleased) {
-    throw new Error("Proxy has been released and is not useable");
-  }
-}
-
-function createProxy<T>(
-  ep: Endpoint,
-  path: (string | number | symbol)[] = [],
-  target: object = function () {}
-): Remote<T> {
-  let isProxyReleased = false;
-  const proxy = new Proxy(target, {
-    get(_target, prop) {
-      throwIfProxyReleased(isProxyReleased);
-      if (prop === releaseProxy) {
-        return () => {
-          return requestResponseMessage(ep, {
-            type: MessageType.RELEASE,
-            path: path.map((p) => p.toString()),
-          }).then(() => {
-            closeEndPoint(ep);
-            isProxyReleased = true;
-          });
-        };
-      }
-      if (prop === "then") {
-        if (path.length === 0) {
-          return { then: () => proxy };
-        }
-        const r = requestResponseMessage(ep, {
-          type: MessageType.GET,
-          path: path.map((p) => p.toString()),
-        }).then(fromWireValue);
-        return r.then.bind(r);
-      }
-      return createProxy(ep, [...path, prop]);
-    },
-    set(_target, prop, rawValue) {
-      throwIfProxyReleased(isProxyReleased);
-      // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
-      // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
-      const [value, transferables] = toWireValue(rawValue);
-      return requestResponseMessage(
-        ep,
-        {
-          type: MessageType.SET,
-          path: [...path, prop].map((p) => p.toString()),
-          value,
-        },
-        transferables
-      ).then(fromWireValue) as any;
-    },
-    apply(_target, _thisArg, rawArgumentList) {
-      throwIfProxyReleased(isProxyReleased);
-      const last = path[path.length - 1];
-      if ((last as any) === createEndpoint) {
-        return requestResponseMessage(ep, {
-          type: MessageType.ENDPOINT,
-        }).then(fromWireValue);
-      }
-      // We just pretend that `bind()` didn’t happen.
-      if (last === "bind") {
-        return createProxy(ep, path.slice(0, -1));
-      }
-      const [argumentList, transferables] = processArguments(rawArgumentList);
-      return requestResponseMessage(
-        ep,
-        {
-          type: MessageType.APPLY,
-          path: path.map((p) => p.toString()),
-          argumentList,
-        },
-        transferables
-      ).then(fromWireValue);
-    },
-    construct(_target, rawArgumentList) {
-      throwIfProxyReleased(isProxyReleased);
-      const [argumentList, transferables] = processArguments(rawArgumentList);
-      return requestResponseMessage(
-        ep,
-        {
-          type: MessageType.CONSTRUCT,
-          path: path.map((p) => p.toString()),
-          argumentList,
-        },
-        transferables
-      ).then(fromWireValue);
-    },
-  });
-  return proxy as any;
-}
-
-function myFlat<T>(arr: (T | T[])[]): T[] {
-  return Array.prototype.concat.apply([], arr);
-}
-
-function processArguments(argumentList: any[]): [WireValue[], Transferable[]] {
-  const processed = argumentList.map(toWireValue);
-  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-}
-
-const transferCache = new WeakMap<any, Transferable[]>();
-export function transfer<T>(obj: T, transfers: Transferable[]): T {
-  transferCache.set(obj, transfers);
-  return obj;
-}
-
-export function proxy<T>(obj: T): T & ProxyMarked {
-  return Object.assign(obj, { [proxyMarker]: true }) as any;
-}
-
-export function windowEndpoint(
-  w: PostMessageWithOrigin,
-  context: EventSource = self,
-  targetOrigin = "*"
-): Endpoint {
-  return {
-    postMessage: (msg: any, transferables: Transferable[]) =>
-      w.postMessage(msg, targetOrigin, transferables),
-    addEventListener: context.addEventListener.bind(context),
-    removeEventListener: context.removeEventListener.bind(context),
-  };
-}
-
-function toWireValue(value: any): [WireValue, Transferable[]] {
-  for (const [name, handler] of transferHandlers) {
-    if (handler.canHandle(value)) {
-      const [serializedValue, transferables] = handler.serialize(value);
-      return [
-        {
-          type: WireValueType.HANDLER,
-          name,
-          value: serializedValue,
-        },
-        transferables,
-      ];
-    }
-  }
-  return [
-    {
-      type: WireValueType.RAW,
-      value,
-    },
-    transferCache.get(value) || [],
-  ];
-}
-
-function fromWireValue(value: WireValue): any {
-  switch (value.type) {
-    case WireValueType.HANDLER:
-      return transferHandlers.get(value.name)!.deserialize(value.value);
-    case WireValueType.RAW:
-      return value.value;
-  }
-}
-
-function requestResponseMessage(
-  ep: Endpoint,
-  msg: Message,
-  transfers?: Transferable[]
-): Promise<WireValue> {
-  return new Promise((resolve) => {
-    const id = generateUUID();
-    ep.addEventListener("message", function l(ev: MessageEvent) {
-      if (!ev.data || !ev.data.id || ev.data.id !== id) {
-        return;
-      }
-      ep.removeEventListener("message", l as any);
-      resolve(ev.data);
-    } as any);
-    if (ep.start) {
-      ep.start();
-    }
-    ep.postMessage({ id, ...msg }, transfers);
-  });
-}
-
-function generateUUID(): string {
-  return new Array(4)
-    .fill(0)
-    .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-    .join("-");
-}