@hylid/call 2.12.0-alpha.18

package/README.md

@@ -0,0 +1,17 @@
+# @hylid/env
+
+## Install
+
+```bash
+npm i @hylid/env --save
+```
+
+## API
+
+```ts
+import { appName, platform, appEnv, platformEnv, APP, PLATFORM } from '@hylid/env';
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="miniprogram" />
+import { MPApi, PickMPArgs, PickMpReturns, Callback } from '@hylid/types';
+import { mpCall } from './mpCall';
+import { mpWebCall } from './mpWebCall';
+import { webCall } from './webCall';
+import { notFound } from './notFound';
+interface Config {
+    type?: string;
+}
+export declare function call<T extends keyof MPApi>(name: T | ({} & string), options?: PickMPArgs<T> | Common | Callback<PickMpReturns<T>>, config?: Config): any;
+export { WebViewBridge } from './webviewBridge';
+export { mpCall, mpWebCall, webCall, notFound };
+export { promisify } from './promisify';

package/lib/index.js

@@ -0,0 +1,17 @@
+var _a;
+import { platform, PLATFORM } from '@hylid/env';
+import { mpCall } from "./mpCall";
+import { mpWebCall } from "./mpWebCall";
+import { webCall } from "./webCall";
+import { notFound } from "./notFound";
+var callMap = (_a = {}, _a[PLATFORM.MP] = mpCall, _a[PLATFORM.MPWEB] = mpWebCall, _a[PLATFORM.WEB] = webCall, _a);
+export function call(name, options, config) {
+  if (platform) {
+    return callMap[platform](name, options, config);
+  } else {
+    return notFound(options, config);
+  }
+}
+export { WebViewBridge } from "./webviewBridge";
+export { mpCall, mpWebCall, webCall, notFound };
+export { promisify } from "./promisify";

package/lib/mpCall.d.ts

@@ -0,0 +1,4 @@
+import { MPApi, PickMPArgs, Callback, PickMpReturns } from '@hylid/types';
+export declare function mpCall<T extends keyof MPApi>(apiName: T | ({} & string), options?: PickMPArgs<T> | Callback<PickMpReturns<T>>, config?: {
+    type?: string;
+}): any;

package/lib/mpCall.js

@@ -0,0 +1,22 @@
+export function mpCall(apiName, options, config) {
+  var _a = (config || {}).type,
+    type = _a === void 0 ? 'async' : _a;
+  if (type === 'sync') {
+    // @ts-ignore
+    return my[apiName](options);
+  }
+  if (type === 'async') {
+    // @ts-ignore
+    if (my[apiName]) {
+      // @ts-ignore
+      my[apiName](options);
+    } else {
+      // @ts-ignore
+      my.call(apiName, options);
+    }
+  }
+  if (type === 'callback') {
+    // @ts-ignore
+    my[apiName](options);
+  }
+}

package/lib/mpWebCall.d.ts

@@ -0,0 +1,6 @@
+import { PickMPArgs, PickMpReturns, MPApi } from '@hylid/types';
+declare type Callback<T> = (result?: T) => void;
+export declare const mpWebCall: <T extends keyof MPApi>(apiName: ({} & string) | T, options?: PickMPArgs<T> | Callback<ReturnType<MPApi[T]>> | undefined, config?: {
+    type?: string;
+}) => void;
+export {};

package/lib/mpWebCall.js

@@ -0,0 +1,100 @@
+var loadAppxBridge = function loadAppxBridge(cb) {
+  try {
+    // @ts-ignore
+    if (window.my) {
+      cb && cb("ready" /* BridgeReady.READY */);
+      return;
+    }
+    var script_1 = document.createElement('script');
+    script_1.src = 'https://appx/web-view.min.js';
+    script_1.onload = function onload() {
+      var readyState = script_1['readyState'];
+      if (typeof readyState === 'undefined' || /^(loaded|complete)$/.test(readyState)) {
+        script_1.onload = null;
+        cb && cb("loaded" /* BridgeReady.LOADED */);
+      }
+    };
+
+    var head = document.getElementsByTagName('head')[0] || document.body;
+    head.appendChild(script_1);
+  } catch (e) {
+    cb && cb(null);
+  }
+};
+var callbackFn = function callbackFn(res, callback) {
+  var _a = callback || {},
+    success = _a.success,
+    fail = _a.fail,
+    complete = _a.complete;
+  // @ts-ignore
+  if (res.error) {
+    fail === null || fail === void 0 ? void 0 : fail(res);
+  } else {
+    success === null || success === void 0 ? void 0 : success(res);
+  }
+  complete === null || complete === void 0 ? void 0 : complete(res);
+};
+export var mpWebCall = function () {
+  var callMap = {};
+  var WAITING_QUEUE = [];
+  var isListening = false;
+  function onMessage() {
+    var messageHandler = window.my.onMessage;
+    window.my.onMessage = function (message) {
+      var serialId = message.serialId;
+      var data = message.result;
+      var type = message.type;
+      if (serialId) {
+        var callback = callMap[serialId];
+        if (type === 'callback') {
+          callback(data);
+        } else {
+          callbackFn(data, callback);
+          delete callMap[serialId];
+        }
+      } else if (messageHandler) {
+        messageHandler(message);
+      }
+    };
+  }
+  function fireMessage(_a) {
+    var apiName = _a.apiName,
+      options = _a.options,
+      config = _a.config;
+    var random = Math.floor(Math.random() * 1000000);
+    var serialId = apiName + '_' + random;
+    if (options) {
+      callMap[serialId] = options;
+    }
+    var params = {
+      type: 'apiCall',
+      api: apiName,
+      serialId: serialId,
+      options: options,
+      config: config
+    };
+    window.my.postMessage(params);
+  }
+  return function call(apiName, options, config) {
+    loadAppxBridge(function (bridgeReady) {
+      var params = {
+        apiName: apiName,
+        options: options,
+        config: config
+      };
+      if (bridgeReady) {
+        if (!isListening) {
+          onMessage();
+          isListening = true;
+        }
+        if (WAITING_QUEUE.length) {
+          WAITING_QUEUE.forEach(fireMessage);
+          WAITING_QUEUE = [];
+        }
+        fireMessage(params);
+      } else {
+        WAITING_QUEUE.push(params);
+      }
+    });
+  };
+}();

package/lib/notFound.d.ts

@@ -0,0 +1 @@
+export declare const notFound: any;

package/lib/notFound.js

@@ -0,0 +1,19 @@
+export var notFound = function notFound(name, opt, config) {
+  var _a;
+  if (config === void 0) {
+    config = {};
+  }
+  var _b = config.type,
+    type = _b === void 0 ? 'async' : _b;
+  var response = {
+    error: -1,
+    errorMessage: "".concat(name, " is not found")
+  };
+  if (type === 'sync') return response;
+  if (type === 'callback') {
+    opt === null || opt === void 0 ? void 0 : opt(response);
+  }
+  if (type === 'async') {
+    (_a = opt === null || opt === void 0 ? void 0 : opt.fail) === null || _a === void 0 ? void 0 : _a.call(opt, response);
+  }
+};

package/lib/promisify.d.ts

@@ -0,0 +1,4 @@
+export interface Options {
+    success?: (res: any) => void;
+}
+export declare const promisify: <T extends Options, P = Parameters<Required<Options> & T["success"]>[0]>(fn: (opt: T) => void) => (args?: Omit<T, "success" | "fail" | "complete"> | undefined) => Promise<P>;

package/lib/promisify.js

@@ -0,0 +1,21 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+export var promisify = function promisify(fn) {
+  return function (args) {
+    return new Promise(function (resolve, reject) {
+      var options = __assign(__assign({}, args), {
+        success: resolve,
+        fail: reject
+      });
+      fn(options);
+    });
+  };
+};

package/lib/webCall.d.ts

@@ -0,0 +1,4 @@
+import { AliJsApi } from '@hylid/types';
+export declare function webCall<T extends keyof AliJsApi.Api>(apiName: T | ({} & string), options?: any, config?: {
+    type?: string;
+}): void;

package/lib/webCall.js

@@ -0,0 +1,29 @@
+var alipayJSBridgeReady = function alipayJSBridgeReady(cb) {
+  if (window.AlipayJSBridge) return cb();
+  document.addEventListener('AlipayJSBridgeReady', function () {
+    return cb();
+  }, false);
+};
+export function webCall(apiName, options, config) {
+  alipayJSBridgeReady(function () {
+    var _a = (config || {}).type,
+      type = _a === void 0 ? 'async' : _a;
+    if (type === 'async') {
+      window.AlipayJSBridge.call(apiName, options, function (res) {
+        var _a = options || {},
+          success = _a.success,
+          fail = _a.fail,
+          complete = _a.complete;
+        if (res.error) {
+          fail === null || fail === void 0 ? void 0 : fail(res);
+        } else {
+          success === null || success === void 0 ? void 0 : success(res);
+        }
+        complete === null || complete === void 0 ? void 0 : complete(res);
+      });
+    }
+    if (type === 'callback') {
+      window.AlipayJSBridge.call(apiName, options);
+    }
+  });
+}

package/lib/webviewBridge.d.ts

@@ -0,0 +1,7 @@
+export declare class WebViewBridge {
+    webview: any;
+    customApi: {};
+    constructor(ctx: any, customApi?: {});
+    listen: (data: any) => Promise<void>;
+    handleApi: (data: any) => Promise<unknown>;
+}

package/lib/webviewBridge.js

@@ -0,0 +1,214 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var WebViewBridge = /** @class */function () {
+  function WebViewBridge(ctx, customApi) {
+    if (customApi === void 0) {
+      customApi = {};
+    }
+    var _this = this;
+    this.customApi = {};
+    this.listen = function (data) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var command, config, api_1, serialId_1, type_1, _a, _b;
+        var _c;
+        var _this = this;
+        return __generator(this, function (_d) {
+          switch (_d.label) {
+            case 0:
+              command = data.detail;
+              if (!command.api) return [3 /*break*/, 3];
+              config = command.config, api_1 = command.api, serialId_1 = command.serialId;
+              type_1 = (config || {}).type;
+              if (!(type_1 === 'callback')) return [3 /*break*/, 1];
+              // @ts-ignore
+              my[api_1](function (res) {
+                _this.webview.postMessage({
+                  api: api_1,
+                  serialId: serialId_1,
+                  type: type_1,
+                  result: res
+                });
+              });
+              return [3 /*break*/, 3];
+            case 1:
+              _b = (_a = this.webview).postMessage;
+              _c = {
+                api: api_1,
+                serialId: serialId_1,
+                type: type_1
+              };
+              return [4 /*yield*/, this.handleApi(command)];
+            case 2:
+              _b.apply(_a, [(_c.result = _d.sent(), _c)]);
+              _d.label = 3;
+            case 3:
+              return [2 /*return*/];
+          }
+        });
+      });
+    };
+
+    this.handleApi = function (data) {
+      var api = data.api,
+        _options = data.options,
+        config = data.config;
+      var _a = (config || {}).type,
+        type = _a === void 0 ? 'async' : _a;
+      return new Promise(function (resolve) {
+        var options = __assign(__assign({}, _options), {
+          success: resolve,
+          fail: function fail(res) {
+            if (!res || !res.error) {
+              resolve(__assign({
+                error: "".concat(api, " error")
+              }, res));
+            } else {
+              resolve(res);
+            }
+          },
+          complete: resolve
+        });
+        // @ts-ignore
+        var mpApi = _this.customApi[api] || my[api];
+        if (type === 'sync') {
+          resolve(mpApi(options));
+        }
+        if (type === 'async') {
+          if (!mpApi) {
+            // @ts-ignore
+            my.call(api, options);
+          } else {
+            mpApi(options);
+          }
+        }
+      });
+    };
+    this.webview = ctx;
+    this.customApi = customApi;
+  }
+  return WebViewBridge;
+}();
+export { WebViewBridge };

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@hylid/call",
+  "version": "2.12.0-alpha.18",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "@hylid/env": "^2.12.0-alpha.18",
+    "@hylid/types": "^2.12.0-alpha.18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "registry": "https://registry.npmjs.org/",
+  "repository": "https://code.alipay.com/ant-ife/hylid-bridge.git"
+}