@wevu/api 0.0.1 → 0.1.1

package/README.md

@@ -2,13 +2,59 @@
 
 ## 简介
 
-`@wevu/api` 是一个轻量的 API 包，目前主要用于提供基础导出与包结构示例，便于后续扩展。
+`@wevu/api` 提供跨平台的小程序 API 封装，默认推荐 Promise 风格，同时兼容传统回调风格。
 
 ## 特性
 
-- 体积小、依赖少
-- 适合承载通用 API 或类型导出
-- 目前提供简单的示例导出
+- 动态代理，覆盖微信小程序全量 API
+- 跨平台适配（微信/支付宝/百度/字节/QQ/快应用/京东/小红书/快手/淘宝等）
+- Promise 风格优先，回调风格可用
+- 支持显式注入平台适配器
+
+## 类型对齐与平台支持
+
+`@wevu/api` 的默认导出 `wpi` 会同时对齐：
+
+- 微信类型：`miniprogram-api-typings`
+- 支付宝类型：`@mini-types/alipay`
+- 抖音类型：`@douyin-microapp/typings`
+
+<!-- prettier-ignore-start -->
+<!-- @generated weapi-support-matrix:start -->
+### 平台类型对齐矩阵
+
+| 平台 | 全局对象 | 类型来源 | 支持度 |
+| --- | --- | --- | --- |
+| 微信小程序 | `wx` | `miniprogram-api-typings` | ✅ 全量 |
+| 支付宝小程序 | `my` | `@mini-types/alipay` | ✅ 全量 |
+| 抖音小程序 | `tt` | `@douyin-microapp/typings` | ✅ 全量 |
+| 其他平台（swan/jd/xhs 等） | 运行时宿主对象 | 运行时透传 | ⚠️ 按宿主能力支持 |
+
+### API 支持覆盖率报告
+
+| 平台 | 已支持 API 数 | API 总数 | 覆盖率 |
+| --- | --- | --- | --- |
+| 微信小程序 (`wx`) | 8 | 8 | 100.00% |
+| 支付宝小程序 (`my`) | 8 | 8 | 100.00% |
+| 抖音小程序 (`tt`) | 8 | 8 | 100.00% |
+| 三端完全对齐 (wx/my/tt) | 8 | 8 | 100.00% |
+
+> 该报告由 `WEAPI_METHOD_SUPPORT_MATRIX` 与映射规则自动计算生成。
+
+### 核心跨端映射矩阵
+
+| API | 说明 | 微信策略 | 支付宝策略 | 抖音策略 | 支持度 |
+| --- | --- | --- | --- | --- | --- |
+| `showToast` | 显示消息提示框。 | 直连 `wx.showToast` | `title/icon` 映射到 `content/type` 后调用 `my.showToast` | `icon=error` 映射为 `fail` 后调用 `tt.showToast` | ✅ |
+| `showLoading` | 显示 loading 提示框。 | 直连 `wx.showLoading` | `title` 映射到 `content` 后调用 `my.showLoading` | 直连 `tt.showLoading` | ✅ |
+| `showActionSheet` | 显示操作菜单。 | 直连 `wx.showActionSheet` | `itemList` ↔ `items`、`index` ↔ `tapIndex` 双向对齐 | 直连 `tt.showActionSheet`，并兼容 `index` → `tapIndex` | ✅ |
+| `showModal` | 显示模态弹窗。 | 直连 `wx.showModal` | 调用 `my.confirm` 并对齐按钮字段与 `cancel` 结果 | 直连 `tt.showModal` | ✅ |
+| `chooseImage` | 选择图片。 | 直连 `wx.chooseImage` | 返回值 `apFilePaths` 映射到 `tempFilePaths` | `tempFilePaths` 字符串转数组，缺失时从 `tempFiles.path` 兜底 | ✅ |
+| `saveFile` | 保存文件。 | 直连 `wx.saveFile` | 请求参数 `tempFilePath` ↔ `apFilePath`、结果映射为 `savedFilePath` | 直连 `tt.saveFile`，并在缺失时用 `filePath` 兜底 `savedFilePath` | ✅ |
+| `setClipboardData` | 设置剪贴板内容。 | 直连 `wx.setClipboardData` | 转调 `my.setClipboard` 并映射 `data` → `text` | 直连 `tt.setClipboardData` | ✅ |
+| `getClipboardData` | 获取剪贴板内容。 | 直连 `wx.getClipboardData` | 转调 `my.getClipboard` 并映射 `text` → `data` | 直连 `tt.getClipboardData` | ✅ |
+<!-- @generated weapi-support-matrix:end -->
+<!-- prettier-ignore-end -->
 
 ## 安装
 
@@ -18,16 +64,56 @@ pnpm add @wevu/api
 
 ## 使用
 
+### Promise 风格（推荐）
+
 ```ts
-import { greet, VERSION } from '@wevu/api'
+import { wpi } from '@wevu/api'
+
+const res = await wpi.request({
+  url: 'https://example.com',
+  method: 'GET',
+})
+
+console.log(res)
+```
+
+### 回调风格（兼容）
+
+```ts
+import { wpi } from '@wevu/api'
+
+wpi.request({
+  url: 'https://example.com',
+  method: 'GET',
+  success(res) {
+    console.log(res)
+  },
+  fail(err) {
+    console.error(err)
+  },
+})
+```
+
+### 显式注入平台适配器
+
+```ts
+import { createWeapi } from '@wevu/api'
+
+const api = createWeapi({
+  adapter: wx,
+  platform: 'wx',
+})
 
-console.log(greet('wevu'))
-console.log(VERSION)
+await api.getSystemInfo()
 ```
 
-## 配置
+## 行为说明
 
-暂无额外配置。
+- **只在不传回调时返回 Promise**
+- 同步 API（`*Sync`）与事件 API（`onXxx/offXxx`）直接透传
+- 缺失 API 时：
+  - 回调风格触发 `fail/complete`
+  - Promise 风格返回 rejected Promise
 
 ## 相关链接
 

package/dist/index.cjs

@@ -1,16 +1,511 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-//#region src/index.ts
+//#region src/core/adapter.ts
+const GLOBAL_ADAPTER_KEYS = [
+	{
+		platform: "wx",
+		key: "wx"
+	},
+	{
+		platform: "my",
+		key: "my"
+	},
+	{
+		platform: "tt",
+		key: "tt"
+	},
+	{
+		platform: "qq",
+		key: "qq"
+	},
+	{
+		platform: "swan",
+		key: "swan"
+	},
+	{
+		platform: "ks",
+		key: "ks"
+	},
+	{
+		platform: "jd",
+		key: "jd"
+	},
+	{
+		platform: "xhs",
+		key: "xhs"
+	},
+	{
+		platform: "dd",
+		key: "dd"
+	},
+	{
+		platform: "qa",
+		key: "qa"
+	},
+	{
+		platform: "qapp",
+		key: "qapp"
+	},
+	{
+		platform: "uni",
+		key: "uni"
+	}
+];
+function resolveGlobalThis() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof window !== "undefined") return window;
+}
+function isAdapterCandidate(value) {
+	return typeof value === "object" || typeof value === "function";
+}
+/**
+* @description 侦测当前运行环境的全局 API 对象
+*/
+function detectGlobalAdapter() {
+	const root = resolveGlobalThis();
+	if (!root) return {};
+	for (const item of GLOBAL_ADAPTER_KEYS) {
+		const candidate = root[item.key];
+		if (isAdapterCandidate(candidate)) return {
+			adapter: candidate,
+			platform: item.platform
+		};
+	}
+	return {};
+}
+
+//#endregion
+//#region src/core/utils.ts
+function isPlainObject(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function hasCallbacks(value) {
+	if (!isPlainObject(value)) return false;
+	return typeof value.success === "function" || typeof value.fail === "function" || typeof value.complete === "function";
+}
+function isSyncMethod(name) {
+	return name.endsWith("Sync");
+}
+function isEventMethod(name) {
+	return /^on[A-Z]/.test(name) || /^off[A-Z]/.test(name);
+}
+function shouldSkipPromise(name) {
+	return isSyncMethod(name) || isEventMethod(name);
+}
+function createNotSupportedError(methodName, platform) {
+	return { errMsg: `${platform ? `${platform}.${methodName}` : methodName}:fail method not supported` };
+}
+
+//#endregion
+//#region src/core/methodMapping.ts
+const PLATFORM_ALIASES$1 = {
+	alipay: "my",
+	douyin: "tt"
+};
+function mapToastType(type) {
+	if (type === "error") return "fail";
+	if (type === "loading") return "none";
+	return type;
+}
+function mapToastArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "content") && Object.prototype.hasOwnProperty.call(nextOptions, "title")) nextOptions.content = nextOptions.title;
+	if (Object.prototype.hasOwnProperty.call(nextOptions, "icon")) nextOptions.type = mapToastType(nextOptions.icon);
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapDouyinToastArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (nextOptions.icon === "error") nextOptions.icon = "fail";
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapLoadingArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "content") && Object.prototype.hasOwnProperty.call(nextOptions, "title")) nextOptions.content = nextOptions.title;
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapActionSheetArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "items") && Array.isArray(nextOptions.itemList)) nextOptions.items = nextOptions.itemList;
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapActionSheetResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "tapIndex") && Object.prototype.hasOwnProperty.call(result, "index")) return {
+		...result,
+		tapIndex: result.index
+	};
+	return result;
+}
+function mapModalArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "confirmButtonText") && Object.prototype.hasOwnProperty.call(nextOptions, "confirmText")) nextOptions.confirmButtonText = nextOptions.confirmText;
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "cancelButtonText") && Object.prototype.hasOwnProperty.call(nextOptions, "cancelText")) nextOptions.cancelButtonText = nextOptions.cancelText;
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapModalResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "cancel") && Object.prototype.hasOwnProperty.call(result, "confirm")) return {
+		...result,
+		cancel: !result.confirm
+	};
+	return result;
+}
+function mapChooseImageResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "tempFilePaths") && Array.isArray(result.apFilePaths)) return {
+		...result,
+		tempFilePaths: result.apFilePaths
+	};
+	return result;
+}
+function mapDouyinChooseImageResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (typeof result.tempFilePaths === "string") return {
+		...result,
+		tempFilePaths: [result.tempFilePaths]
+	};
+	if (!Array.isArray(result.tempFilePaths) && Array.isArray(result.tempFiles)) {
+		const fallbackPaths = result.tempFiles.map((item) => {
+			if (!isPlainObject(item)) return;
+			const path = item.path;
+			if (typeof path === "string" && path) return path;
+			const filePath = item.filePath;
+			if (typeof filePath === "string" && filePath) return filePath;
+		}).filter((item) => typeof item === "string");
+		if (fallbackPaths.length > 0) return {
+			...result,
+			tempFilePaths: fallbackPaths
+		};
+	}
+	return result;
+}
+function mapSaveFileArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "apFilePath") && Object.prototype.hasOwnProperty.call(nextOptions, "tempFilePath")) nextOptions.apFilePath = nextOptions.tempFilePath;
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapSaveFileResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "savedFilePath") && Object.prototype.hasOwnProperty.call(result, "apFilePath")) return {
+		...result,
+		savedFilePath: result.apFilePath
+	};
+	return result;
+}
+function mapDouyinSaveFileResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "savedFilePath") && Object.prototype.hasOwnProperty.call(result, "filePath")) return {
+		...result,
+		savedFilePath: result.filePath
+	};
+	return result;
+}
+function normalizePlatformName$1(value) {
+	if (!value) return;
+	const normalized = value.trim().toLowerCase();
+	if (!normalized) return;
+	return PLATFORM_ALIASES$1[normalized] ?? normalized;
+}
+function mapSetClipboardArgs(args) {
+	if (args.length === 0) return args;
+	const nextArgs = [...args];
+	const lastIndex = nextArgs.length - 1;
+	const lastArg = nextArgs[lastIndex];
+	if (!isPlainObject(lastArg)) return nextArgs;
+	const nextOptions = { ...lastArg };
+	if (!Object.prototype.hasOwnProperty.call(nextOptions, "text") && Object.prototype.hasOwnProperty.call(nextOptions, "data")) nextOptions.text = nextOptions.data;
+	nextArgs[lastIndex] = nextOptions;
+	return nextArgs;
+}
+function mapClipboardResult(result) {
+	if (!isPlainObject(result)) return result;
+	if (!Object.prototype.hasOwnProperty.call(result, "data") && Object.prototype.hasOwnProperty.call(result, "text")) return {
+		...result,
+		data: result.text
+	};
+	return result;
+}
+const METHOD_MAPPINGS = {
+	my: {
+		showToast: {
+			target: "showToast",
+			mapArgs: mapToastArgs
+		},
+		showLoading: {
+			target: "showLoading",
+			mapArgs: mapLoadingArgs
+		},
+		showActionSheet: {
+			target: "showActionSheet",
+			mapArgs: mapActionSheetArgs,
+			mapResult: mapActionSheetResult
+		},
+		showModal: {
+			target: "confirm",
+			mapArgs: mapModalArgs,
+			mapResult: mapModalResult
+		},
+		chooseImage: {
+			target: "chooseImage",
+			mapResult: mapChooseImageResult
+		},
+		saveFile: {
+			target: "saveFile",
+			mapArgs: mapSaveFileArgs,
+			mapResult: mapSaveFileResult
+		},
+		setClipboardData: {
+			target: "setClipboard",
+			mapArgs: mapSetClipboardArgs
+		},
+		getClipboardData: {
+			target: "getClipboard",
+			mapResult: mapClipboardResult
+		}
+	},
+	tt: {
+		showToast: {
+			target: "showToast",
+			mapArgs: mapDouyinToastArgs
+		},
+		showLoading: { target: "showLoading" },
+		showActionSheet: {
+			target: "showActionSheet",
+			mapResult: mapActionSheetResult
+		},
+		showModal: { target: "showModal" },
+		chooseImage: {
+			target: "chooseImage",
+			mapResult: mapDouyinChooseImageResult
+		},
+		saveFile: {
+			target: "saveFile",
+			mapResult: mapDouyinSaveFileResult
+		},
+		setClipboardData: { target: "setClipboardData" },
+		getClipboardData: { target: "getClipboardData" }
+	}
+};
+/**
+* @description 解析平台 API 映射规则
+*/
+function resolveMethodMapping(platform, methodName) {
+	const normalizedPlatform = normalizePlatformName$1(platform);
+	if (!normalizedPlatform) return;
+	const platformMappings = METHOD_MAPPINGS[normalizedPlatform];
+	if (!platformMappings) return;
+	return platformMappings[methodName];
+}
+
+//#endregion
+//#region src/core/createWeapi.ts
+const INTERNAL_KEYS = new Set([
+	"setAdapter",
+	"getAdapter",
+	"platform",
+	"raw"
+]);
+const PLATFORM_ALIASES = {
+	alipay: "my",
+	douyin: "tt"
+};
+function normalizePlatformName(value) {
+	if (!value) return;
+	const normalized = value.trim().toLowerCase();
+	if (!normalized) return;
+	return PLATFORM_ALIASES[normalized] ?? normalized;
+}
+function resolveOptionsArg(args) {
+	const nextArgs = args.slice();
+	const lastArg = nextArgs.length > 0 ? nextArgs[nextArgs.length - 1] : void 0;
+	if (isPlainObject(lastArg)) {
+		const options = { ...lastArg };
+		nextArgs[nextArgs.length - 1] = options;
+		return {
+			args: nextArgs,
+			options
+		};
+	}
+	const options = {};
+	nextArgs.push(options);
+	return {
+		args: nextArgs,
+		options
+	};
+}
+function callWithPromise(context, method, args, mapResult) {
+	return new Promise((resolve, reject) => {
+		const { args: nextArgs, options } = resolveOptionsArg(args);
+		let settled = false;
+		options.success = (res) => {
+			settled = true;
+			resolve(mapResult ? mapResult(res) : res);
+		};
+		options.fail = (err) => {
+			settled = true;
+			reject(err);
+		};
+		options.complete = (res) => {
+			if (!settled) resolve(mapResult ? mapResult(res) : res);
+		};
+		try {
+			method.apply(context, nextArgs);
+		} catch (err) {
+			reject(err);
+		}
+	});
+}
+function callMissingApi(methodName, platform, args) {
+	const lastArg = args.length > 0 ? args[args.length - 1] : void 0;
+	const error = createNotSupportedError(methodName, platform);
+	if (hasCallbacks(lastArg)) {
+		lastArg.fail?.(error);
+		lastArg.complete?.(error);
+		return;
+	}
+	return Promise.reject(error);
+}
 /**
-* @description 简单的问候函数
+* @description 创建跨平台 API 实例
 */
-function greet(name) {
-	return `hello ${name}`;
+function createWeapi(options = {}) {
+	let adapter = options.adapter;
+	let platformName = normalizePlatformName(options.platform);
+	const cache = /* @__PURE__ */ new Map();
+	const resolveAdapter = () => {
+		if (adapter) return adapter;
+		const detected = detectGlobalAdapter();
+		if (detected.adapter) {
+			adapter = detected.adapter;
+			platformName = platformName ?? normalizePlatformName(detected.platform);
+		}
+		return adapter;
+	};
+	const setAdapter = (nextAdapter, nextPlatform) => {
+		adapter = nextAdapter;
+		platformName = normalizePlatformName(nextPlatform);
+		cache.clear();
+	};
+	const getAdapter = () => {
+		if (!adapter) resolveAdapter();
+		return adapter;
+	};
+	const getPlatform = () => {
+		if (!platformName) resolveAdapter();
+		return platformName;
+	};
+	return new Proxy({}, { get(_target, prop) {
+		if (prop === Symbol.toStringTag) return "Weapi";
+		if (prop === "then") return;
+		if (INTERNAL_KEYS.has(prop)) {
+			if (prop === "setAdapter") return setAdapter;
+			if (prop === "getAdapter") return getAdapter;
+			if (prop === "platform") return getPlatform();
+			if (prop === "raw") return getAdapter();
+		}
+		if (cache.has(prop)) return cache.get(prop);
+		const currentAdapter = resolveAdapter();
+		if (!currentAdapter) {
+			if (typeof prop !== "string") return;
+			return (...args) => callMissingApi(prop, getPlatform(), args);
+		}
+		const platform = getPlatform();
+		const value = currentAdapter[(typeof prop === "string" ? resolveMethodMapping(platform, prop) : void 0)?.target ?? prop];
+		if (typeof value !== "function") {
+			if (value === void 0 && typeof prop === "string") {
+				const missing = (...args) => callMissingApi(prop, getPlatform(), args);
+				cache.set(prop, missing);
+				return missing;
+			}
+			cache.set(prop, value);
+			return value;
+		}
+		const wrapped = (...args) => {
+			const runtimeAdapter = resolveAdapter();
+			const mappingRule = resolveMethodMapping(getPlatform(), prop);
+			const methodName = mappingRule?.target ?? prop;
+			const runtimeMethod = runtimeAdapter ? runtimeAdapter[methodName] : void 0;
+			const runtimeArgs = mappingRule?.mapArgs ? mappingRule.mapArgs(args) : args;
+			if (typeof runtimeMethod !== "function") return callMissingApi(prop, getPlatform(), args);
+			if (shouldSkipPromise(prop)) {
+				const result = runtimeMethod.apply(runtimeAdapter, runtimeArgs);
+				return mappingRule?.mapResult ? mappingRule.mapResult(result) : result;
+			}
+			const lastArg = runtimeArgs.length > 0 ? runtimeArgs[runtimeArgs.length - 1] : void 0;
+			if (hasCallbacks(lastArg)) {
+				if (mappingRule?.mapResult && isPlainObject(lastArg)) {
+					const options = lastArg;
+					const originalSuccess = options.success;
+					const originalComplete = options.complete;
+					options.success = (res) => {
+						originalSuccess?.(mappingRule.mapResult(res));
+					};
+					options.complete = (res) => {
+						originalComplete?.(mappingRule.mapResult(res));
+					};
+				}
+				const result = runtimeMethod.apply(runtimeAdapter, runtimeArgs);
+				return mappingRule?.mapResult ? mappingRule.mapResult(result) : result;
+			}
+			return callWithPromise(runtimeAdapter, runtimeMethod, runtimeArgs, mappingRule?.mapResult);
+		};
+		cache.set(prop, wrapped);
+		return wrapped;
+	} });
 }
+
+//#endregion
+//#region src/index.ts
 /**
-* @description 当前包版本号
+* @description 默认跨平台 API 实例（推荐使用）
+*
+* @generated weapi-platform-matrix:start
+* | 平台 | 类型来源 | 支持度 |
+* | --- | --- | --- |
+* | 微信小程序 (`wx`) | `miniprogram-api-typings` | ✅ 全量 |
+* | 支付宝小程序 (`my`) | `@mini-types/alipay` | ✅ 全量 |
+* | 抖音小程序 (`tt`) | `@douyin-microapp/typings` | ✅ 全量 |
+* | 其他平台对象 (`swan/jd/xhs/...`) | 运行时对象透传 | ⚠️ 按宿主能力支持 |
+* @generated weapi-platform-matrix:end
 */
-const VERSION = "0.0.0";
+const wpi = createWeapi();
 
 //#endregion
-exports.VERSION = VERSION;
-exports.greet = greet;
+exports.createWeapi = createWeapi;
+exports.wpi = wpi;