forked from dcloudio/uni-app
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
20 changed files
with
839 additions
and
17 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,9 @@ | ||
| export declare const extend: { | ||
| <T extends {}, U>(target: T, source: U): T & U; | ||
| <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V; | ||
| <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W; | ||
| (target: object, ...sources: any[]): any; | ||
| }; | ||
| export declare const hasOwn: (val: object, key: string | symbol) => key is never; | ||
| export declare const isPlainObject: (val: unknown) => val is object; | ||
| export declare const capitalize: (str: string) => string; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,23 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.capitalize = exports.isPlainObject = exports.hasOwn = exports.extend = void 0; | ||
| exports.extend = Object.assign; | ||
| var hasOwnProperty = Object.prototype.hasOwnProperty; | ||
| var hasOwn = function (val, key) { return hasOwnProperty.call(val, key); }; | ||
| exports.hasOwn = hasOwn; | ||
| var objectToString = Object.prototype.toString; | ||
| var toTypeString = function (value) { | ||
| return objectToString.call(value); | ||
| }; | ||
| var isPlainObject = function (val) { | ||
| return toTypeString(val) === '[object Object]'; | ||
| }; | ||
| exports.isPlainObject = isPlainObject; | ||
| var cacheStringFunction = function (fn) { | ||
| var cache = Object.create(null); | ||
| return (function (str) { | ||
| var hit = cache[str]; | ||
| return hit || (cache[str] = fn(str)); | ||
| }); | ||
| }; | ||
| exports.capitalize = cacheStringFunction(function (str) { return str.charAt(0).toUpperCase() + str.slice(1); }); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,42 @@ | ||
| export declare function normalizeArg(arg: unknown): unknown; | ||
| interface Parameter { | ||
| name: string; | ||
| type: string; | ||
| } | ||
| interface ProxyFunctionOptions { | ||
| main?: boolean; | ||
| package: string; | ||
| class: string; | ||
| name: string; | ||
| method?: string; | ||
| companion?: boolean; | ||
| params: Parameter[]; | ||
| } | ||
| interface ProxyClassOptions { | ||
| package: string; | ||
| class: string; | ||
| constructor: { | ||
| params: Parameter[]; | ||
| }; | ||
| props: string[]; | ||
| staticProps: string[]; | ||
| methods: { | ||
| [name: string]: { | ||
| async?: boolean; | ||
| params: Parameter[]; | ||
| }; | ||
| }; | ||
| staticMethods: { | ||
| [name: string]: { | ||
| async?: boolean; | ||
| params: Parameter[]; | ||
| }; | ||
| }; | ||
| } | ||
| declare function initUtsStaticMethod(async: boolean, opts: ProxyFunctionOptions): (...args: unknown[]) => unknown; | ||
| export declare const initUtsProxyFunction: typeof initUtsStaticMethod; | ||
| export declare function initUtsProxyClass({ package: pkg, class: cls, constructor: { params: constructorParams }, methods, props, staticProps, staticMethods, }: ProxyClassOptions): any; | ||
| export declare function initUtsPackageName(name: string, is_uni_modules: boolean): string; | ||
| export declare function initUtsIndexClassName(moduleName: string, is_uni_modules: boolean): string; | ||
| export declare function initUtsClassName(moduleName: string, className: string, is_uni_modules: boolean): string; | ||
| export {}; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,186 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: 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 id = 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) { | ||
| 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; | ||
| 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]; | ||
| } | ||
| 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; | ||
| var baseOptions = { | ||
| package: pkg, | ||
| class: cls, | ||
| }; | ||
| var ProxyClass = (function () { | ||
| function UtsClass() { | ||
| var params = []; | ||
| for (var _i = 0; _i < arguments.length; _i++) { | ||
| params[_i] = arguments[_i]; | ||
| } | ||
| var target = {}; | ||
| 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 }); | ||
| } | ||
| } | ||
| 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; |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,26 @@ | ||
| export const extend = Object.assign | ||
|
|
||
| const hasOwnProperty = Object.prototype.hasOwnProperty | ||
| export const hasOwn = ( | ||
| val: object, | ||
| key: string | symbol | ||
| ): key is keyof typeof val => hasOwnProperty.call(val, key) | ||
|
|
||
| const objectToString = Object.prototype.toString | ||
| const toTypeString = (value: unknown): string => | ||
| objectToString.call(value) | ||
|
|
||
| export const isPlainObject = (val: unknown): val is object => | ||
| toTypeString(val) === '[object Object]' | ||
|
|
||
| const cacheStringFunction = <T extends (str: string) => string>(fn: T): T => { | ||
| const cache: Record<string, string> = Object.create(null) | ||
| return ((str: string) => { | ||
| const hit = cache[str] | ||
| return hit || (cache[str] = fn(str)) | ||
| }) as T | ||
| } | ||
|
|
||
| export const capitalize = cacheStringFunction( | ||
| (str: string) => str.charAt(0).toUpperCase() + str.slice(1) | ||
| ) |
Oops, something went wrong.