"use strict";
|
exports.__esModule = true;
|
exports.initUtsClassName = exports.initUtsIndexClassName = exports.initUtsPackageName = exports.initUtsProxyClass = exports.initUtsProxyFunction = exports.normalizeArg = void 0;
|
var utils_1 = require("./utils");
|
var callbackId = 1;
|
var proxy;
|
var callbacks = {};
|
function normalizeArg(arg) {
|
if (typeof arg === 'function') {
|
// 查找该函数是否已缓存
|
var oldId = Object.keys(callbacks).find(function (id) { return callbacks[id] === arg; });
|
var id = oldId ? parseInt(oldId) : callbackId++;
|
callbacks[id] = arg;
|
return id;
|
}
|
else if ((0, utils_1.isPlainObject)(arg)) {
|
Object.keys(arg).forEach(function (name) {
|
;
|
arg[name] = normalizeArg(arg[name]);
|
});
|
}
|
return arg;
|
}
|
exports.normalizeArg = normalizeArg;
|
function initUtsInstanceMethod(async, opts, instanceId) {
|
return initProxyFunction(async, opts, instanceId);
|
}
|
function getProxy() {
|
if (!proxy) {
|
proxy = uni.requireNativePlugin('UTS-Proxy');
|
}
|
return proxy;
|
}
|
function resolveSyncResult(res) {
|
if (res.errMsg) {
|
throw new Error(res.errMsg);
|
}
|
return res.params;
|
}
|
function invokePropGetter(args) {
|
if (args.errMsg) {
|
throw new Error(args.errMsg);
|
}
|
delete args.errMsg;
|
return resolveSyncResult(getProxy().invokeSync(args, function () { }));
|
}
|
function initProxyFunction(async, _a, instanceId) {
|
var pkg = _a.package, cls = _a["class"], propOrMethod = _a.name, method = _a.method, companion = _a.companion, methodParams = _a.params, errMsg = _a.errMsg;
|
var invokeCallback = function (_a) {
|
var id = _a.id, name = _a.name, params = _a.params, keepAlive = _a.keepAlive;
|
var callback = callbacks[id];
|
if (callback) {
|
callback.apply(void 0, params);
|
if (!keepAlive) {
|
delete callbacks[id];
|
}
|
}
|
else {
|
console.error("".concat(pkg).concat(cls, ".").concat(propOrMethod, " ").concat(name, " is not found"));
|
}
|
};
|
var baseArgs = instanceId
|
? { id: instanceId, name: propOrMethod, method: methodParams }
|
: {
|
package: pkg,
|
"class": cls,
|
name: method || propOrMethod,
|
companion: companion,
|
method: methodParams
|
};
|
return function () {
|
var args = [];
|
for (var _i = 0; _i < arguments.length; _i++) {
|
args[_i] = arguments[_i];
|
}
|
if (errMsg) {
|
throw new Error(errMsg);
|
}
|
var invokeArgs = (0, utils_1.extend)({}, baseArgs, {
|
params: args.map(function (arg) { return normalizeArg(arg); })
|
});
|
if (async) {
|
return new Promise(function (resolve, reject) {
|
getProxy().invokeAsync(invokeArgs, function (res) {
|
if (res.type !== 'return') {
|
invokeCallback(res);
|
}
|
else {
|
if (res.errMsg) {
|
reject(res.errMsg);
|
}
|
else {
|
resolve(res.params);
|
}
|
}
|
});
|
});
|
}
|
return resolveSyncResult(getProxy().invokeSync(invokeArgs, invokeCallback));
|
};
|
}
|
function initUtsStaticMethod(async, opts) {
|
if (opts.main && !opts.method) {
|
if (typeof plus !== 'undefined' && plus.os.name === 'iOS') {
|
opts.method = 's_' + opts.name;
|
}
|
}
|
return initProxyFunction(async, opts, 0);
|
}
|
exports.initUtsProxyFunction = initUtsStaticMethod;
|
function initUtsProxyClass(_a) {
|
var pkg = _a.package, cls = _a["class"], constructorParams = _a.constructor.params, methods = _a.methods, props = _a.props, staticProps = _a.staticProps, staticMethods = _a.staticMethods, errMsg = _a.errMsg;
|
var baseOptions = {
|
package: pkg,
|
"class": cls,
|
errMsg: errMsg
|
};
|
var ProxyClass = /** @class */ (function () {
|
function UtsClass() {
|
var params = [];
|
for (var _i = 0; _i < arguments.length; _i++) {
|
params[_i] = arguments[_i];
|
}
|
if (errMsg) {
|
throw new Error(errMsg);
|
}
|
var target = {};
|
// 初始化实例 ID
|
var instanceId = initProxyFunction(false, (0, utils_1.extend)({ name: 'constructor', params: constructorParams }, baseOptions), 0).apply(null, params);
|
if (!instanceId) {
|
throw new Error("new ".concat(cls, " is failed"));
|
}
|
return new Proxy(this, {
|
get: function (_, name) {
|
if (!target[name]) {
|
//实例方法
|
if ((0, utils_1.hasOwn)(methods, name)) {
|
var _a = methods[name], async = _a.async, params_1 = _a.params;
|
target[name] = initUtsInstanceMethod(!!async, (0, utils_1.extend)({
|
name: name,
|
params: params_1
|
}, baseOptions), instanceId);
|
}
|
else if (props.includes(name)) {
|
// 实例属性
|
return invokePropGetter({
|
id: instanceId,
|
name: name,
|
errMsg: errMsg
|
});
|
}
|
}
|
return target[name];
|
}
|
});
|
}
|
return UtsClass;
|
}());
|
var staticMethodCache = {};
|
return new Proxy(ProxyClass, {
|
get: function (target, name, receiver) {
|
if ((0, utils_1.hasOwn)(staticMethods, name)) {
|
if (!staticMethodCache[name]) {
|
var _a = staticMethods[name], async = _a.async, params = _a.params;
|
// 静态方法
|
staticMethodCache[name] = initUtsStaticMethod(!!async, (0, utils_1.extend)({ name: name, companion: true, params: params }, baseOptions));
|
}
|
return staticMethodCache[name];
|
}
|
if (staticProps.includes(name)) {
|
// 静态属性
|
return invokePropGetter((0, utils_1.extend)({ name: name, companion: true }, baseOptions));
|
}
|
return Reflect.get(target, name, receiver);
|
}
|
});
|
}
|
exports.initUtsProxyClass = initUtsProxyClass;
|
function initUtsPackageName(name, is_uni_modules) {
|
if (typeof plus !== 'undefined' && plus.os.name === 'Android') {
|
return 'uts.sdk.' + (is_uni_modules ? 'modules.' : '') + name;
|
}
|
return '';
|
}
|
exports.initUtsPackageName = initUtsPackageName;
|
function initUtsIndexClassName(moduleName, is_uni_modules) {
|
if (typeof plus === 'undefined') {
|
return '';
|
}
|
return initUtsClassName(moduleName, plus.os.name === 'iOS' ? 'IndexSwift' : 'IndexKt', is_uni_modules);
|
}
|
exports.initUtsIndexClassName = initUtsIndexClassName;
|
function initUtsClassName(moduleName, className, is_uni_modules) {
|
if (typeof plus === 'undefined') {
|
return '';
|
}
|
if (plus.os.name === 'Android') {
|
return className;
|
}
|
if (plus.os.name === 'iOS') {
|
return ('UTSSDK' +
|
(is_uni_modules ? 'Modules' : '') +
|
(0, utils_1.capitalize)(moduleName) +
|
(0, utils_1.capitalize)(className));
|
}
|
return '';
|
}
|
exports.initUtsClassName = initUtsClassName;
|
