├── .gitignore
├── src
    └── framework
    │   ├── platform
    │       ├── dev
    │       │   ├── index.ts
    │       │   ├── page
    │       │   │   ├── iphonex.html
    │       │   │   └── debug-panel.html
    │       │   ├── recorder.dev.ts
    │       │   └── platform.dev.ts
    │       ├── wechat
    │       │   ├── index.ts
    │       │   ├── storage.wechat.ts
    │       │   ├── wx.webaudio.d.ts
    │       │   ├── downloader.wechat.ts
    │       │   ├── websocket.wechat.ts
    │       │   ├── xhr.wechat.ts
    │       │   ├── wx-patch.d.ts
    │       │   └── fs.wechat.ts
    │       ├── kuaishou
    │       │   ├── index.ts
    │       │   ├── storage.kuaishou.ts
    │       │   ├── downloader.kuaishou.ts
    │       │   ├── websocket.kuaishou.ts
    │       │   ├── recorder.kuaishou.ts
    │       │   ├── xhr.kuaishou.ts
    │       │   ├── fs.kuaishou.ts
    │       │   └── platform.kuaishou.ts
    │       ├── bytedance
    │       │   ├── index.ts
    │       │   ├── storage.bytedance.ts
    │       │   ├── downloader.bytedance.ts
    │       │   ├── websocket.bytedance.ts
    │       │   ├── recorder.bytedance.ts
    │       │   ├── xhr.bytedance.ts
    │       │   └── fs.bytedance.ts
    │       ├── utils
    │       │   ├── index.ts
    │       │   └── SubPackageLoader.ts
    │       ├── web
    │       │   ├── downloader.web.ts
    │       │   ├── websocket.web.ts
    │       │   ├── canvas.ts
    │       │   ├── platform.web.basic.ts
    │       │   ├── fs.web.ts
    │       │   └── platform.web.ts
    │       └── platform.common.ts
    │   ├── @types
    │       ├── files.d.ts
    │       ├── http.d.ts
    │       ├── websocket.d.ts
    │       ├── sdk.d.ts
    │       ├── IFileDownloader.d.ts
    │       ├── recorder.d.ts
    │       ├── fs.d.ts
    │       ├── env.d.ts
    │       ├── global.d.ts
    │       └── EventEmitter.d.ts
    │   ├── tiny
    │       ├── core
    │       │   ├── TinyObject.ts
    │       │   ├── HashObject.ts
    │       │   ├── global.ts
    │       │   ├── EventEmitter.ts
    │       │   └── async-operation
    │       │   │   └── AsyncOperation.ts
    │       └── utils
    │       │   ├── promise.ts
    │       │   ├── StateMachine.basic.ts
    │       │   ├── fs
    │       │       ├── FileUtils.ts
    │       │       ├── fs.xhr.ts
    │       │       └── fs.sizelimited.ts
    │       │   ├── deferred.ts
    │       │   ├── FileDownloader.xhr.ts
    │       │   ├── format.ts
    │       │   ├── path.ts
    │       │   ├── http.xhr.ts
    │       │   └── index.ts
    │   ├── webapi
    │       └── xhr
    │       │   ├── url.ts
    │       │   ├── webapi.xhr.d.ts
    │       │   └── xhr.common.ts
    │   └── common
    │       ├── exception.ts
    │       └── constants.ts
├── README.md
├── tsconfig.json
├── LICENSE
├── package.json
└── webpack.config.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | build/
3 | yarn.lock
4 | 


--------------------------------------------------------------------------------
/src/framework/platform/dev/index.ts:
--------------------------------------------------------------------------------
1 | import '../web';
2 | import './platform.dev';
3 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/index.ts:
--------------------------------------------------------------------------------
1 | import './xhr.wechat';
2 | import './platform.wechat';
3 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/index.ts:
--------------------------------------------------------------------------------
1 | import './xhr.kuaishou';
2 | import './platform.kuaishou';
3 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/index.ts:
--------------------------------------------------------------------------------
1 | import './xhr.bytedance';
2 | import './platform.bytedance';
3 | 


--------------------------------------------------------------------------------
/src/framework/@types/files.d.ts:
--------------------------------------------------------------------------------
1 | declare module '*.txt';
2 | declare module '*.yaml';
3 | declare module '*.html';
4 | 


--------------------------------------------------------------------------------
/src/framework/tiny/core/TinyObject.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from './EventEmitter';
 2 | import { HashObject } from './HashObject';
 3 | 
 4 | export class TinyObject extends HashObject {
 5 | 	/** 事件派发器 */
 6 | 	readonly event = new EventEmitter();
 7 | 
 8 | 	/** 执行清理/销毁操作，执行该操作之后不应再继续使用该对象 */
 9 | 	dispose() {
10 | 		this.event.dispose();
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/src/framework/webapi/xhr/url.ts:
--------------------------------------------------------------------------------
 1 | export interface IURL {
 2 | 	url: string;
 3 | 	hostname?: string;
 4 | 	path?: string;
 5 | 	port?: number;
 6 | 	protocal?: string;
 7 | }
 8 | import parse from 'url-parse';
 9 | export function parseUrl(url: string): IURL {
10 | 	const ret = parse(url);
11 | 	Object.assign(ret, { url });
12 | 	return ret as unknown as IURL;
13 | }
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/storage.wechat.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | export class WechatLocalStorage implements LocalStorage {
 3 | 	getItem(key: string): string {
 4 | 		return wx.getStorageSync(key);
 5 | 	}
 6 | 
 7 | 	setItem(key: string, value: string): void {
 8 | 		wx.setStorageSync(key, value);
 9 | 	}
10 | 
11 | 	clear() {
12 | 		wx.clearStorageSync();
13 | 	}
14 | 
15 | 	removeItem(key: string) {
16 | 		wx.removeStorageSync(key);
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/storage.bytedance.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | export class BytedanceLocalStorage implements LocalStorage {
 3 | 	getItem(key: string): string {
 4 | 		return tt.getStorageSync(key);
 5 | 	}
 6 | 
 7 | 	setItem(key: string, value: string): void {
 8 | 		tt.setStorageSync(key, value);
 9 | 	}
10 | 
11 | 	clear() {
12 | 		tt.clearStorageSync();
13 | 	}
14 | 
15 | 	removeItem(key: string) {
16 | 		tt.removeStorageSync(key);
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/storage.kuaishou.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | export class KuaishouLocalStorage implements LocalStorage {
 3 | 	getItem(key: string): string {
 4 | 		return ks.getStorageSync(key);
 5 | 	}
 6 | 
 7 | 	setItem(key: string, value: string): void {
 8 | 		ks.setStorageSync(key, value);
 9 | 	}
10 | 
11 | 	clear() {
12 | 		ks.clearStorageSync();
13 | 	}
14 | 
15 | 	removeItem(key: string) {
16 | 		ks.removeStorageSync(key);
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/src/framework/platform/utils/index.ts:
--------------------------------------------------------------------------------
 1 | import { globalGet, globalSet } from 'framework/tiny/core/global';
 2 | 
 3 | export function DefinePlatfrom(type: new () => Platform) {
 4 | 	globalSet('getPlatform', function getPlatform() {
 5 | 		let platform: Platform = globalGet('platform');
 6 | 		if (platform) return platform;
 7 | 		platform = new type;
 8 | 		globalSet("platform", platform);
 9 | 		console.log('[platform]', '当前平台', platform);
10 | 		return platform;
11 | 	});
12 | }
13 | 


--------------------------------------------------------------------------------
/src/framework/@types/http.d.ts:
--------------------------------------------------------------------------------
 1 | type HttpRequestMethod = 'GET' | 'POST' | 'DELETE' | 'PUT';
 2 | 
 3 | declare interface http {
 4 | 	/** 发起 HTTP 请求 */
 5 | 	fetch(method: HttpRequestMethod, url: string, body?: BodyInit | Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any>;
 6 | 	/** 发起 POST 请求 */
 7 | 	post(url: string | string, data?: BodyInit | Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any>;
 8 | 	/** 发起 GET 请求 */
 9 | 	get(url: string | string, params?: Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any>;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/framework/@types/websocket.d.ts:
--------------------------------------------------------------------------------
 1 | declare interface TinyWebSocket {
 2 | 
 3 | 	/** 断开连接时被调用 */
 4 | 	onclose: (event: { code: number; reason: string; }) => void;
 5 | 	/** 连接错误时被调用 */
 6 | 	onerror: (event: { code: number; message: string }) => void;
 7 | 	/** 收到数据时被调用 */
 8 | 	onmessage: (data: string | ArrayBuffer) => void;
 9 | 	/** 建立连接后被调用 */
10 | 	onopen: () => void;
11 | 	/** 断开连接 */
12 | 	close(code?: number, reason?: string): Promise<void>;
13 | 	/** 发送数据 */
14 | 	send(data: string | ArrayBufferLike): Promise<void>;
15 | }
16 | 
17 | declare type TinyWebSocketClass = new (url: string, protocols?: string | string[]) => TinyWebSocket;
18 | 


--------------------------------------------------------------------------------
/src/framework/tiny/core/HashObject.ts:
--------------------------------------------------------------------------------
 1 | export type Nullable<T> = T | null;
 2 | 
 3 | /**
 4 |  * 框架内所有对象的基类，为对象实例提供唯一的hashCode值。
 5 |  */
 6 | export interface IHashObject {
 7 | 	/**
 8 | 	 * 返回此对象唯一的哈希值,用于唯一确定一个对象。hashCode为大于等于1的整数。
 9 | 	 */
10 | 	readonly hashCode: number;
11 | }
12 | 
13 | /**
14 |  * 哈希计数
15 |  */
16 | let $hashCount: number = 0;
17 | 
18 | /** 生成新的 HashCode */
19 | export function GenerateObjectHashCode() {
20 | 	return ++$hashCount;
21 | }
22 | 
23 | export class HashObject implements IHashObject {
24 | 	private $hashCode = GenerateObjectHashCode();
25 | 	get hashCode() {
26 | 		return this.$hashCode;
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/wx.webaudio.d.ts:
--------------------------------------------------------------------------------
 1 | declare namespace wx {
 2 | 	interface WebAudioContext {
 3 | 		/** 获取当前上下文的时间戳。*/
 4 | 		currentTime: number;
 5 | 		/** 当前上下文的最终目标节点，一般是音频渲染设备 */
 6 | 		destination: AudioDestinationNode;
 7 | 
 8 | 		/** 异步解码一段资源为AudioBuffer。 */
 9 | 		decodeAudioData(data: ArrayBuffer, success: (buffer: AudioBuffer) => void, fail: (err: string) => void);
10 | 
11 | 		/** 创建一个BufferSourceNode实例，通过AudioBuffer对象来播放音频数据 */
12 | 		createBufferSource(): AudioBufferSourceNode;
13 | 
14 | 		/** 创建一个GainNode */
15 | 		createGain(): GainNode;
16 | 	}
17 | 	/** 创建 WebAudio 上下文。 */
18 | 	function createWebAudioContext(): WebAudioContext;
19 | }
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # platform
 2 | 游戏运行时的平台抽象层，实现统一的接口，方便游戏开发调用平台能力不必关心底层平台的差异。与游戏引擎解耦，方便在不同引擎中使用。
 3 | 
 4 | 已在多个小游戏项目中被使用、在数千万台设备中运行过，稳定可靠。
 5 | 
 6 | ### 提供的主要功能
 7 | - 文件系统，包括读写文件、创建目录、删除文件等
 8 |   - 适配小游戏写入空间大小受限的环境
 9 |   - 只读文件系统，支持读取小游戏包内文件，自动触发分包加载
10 | - 网络: 提供统一的网络请求功能，支持 http、https、websocket
11 | - 数据存储: 提供统一的数据存储功能
12 | - 启动参数，获取启动游戏时的参数，如启动场景、买量归因参数、自定义启动参数等
13 | - 用户信息授权与获取（平台登陆等操作）
14 | - 分享（图片、文本、录屏）
15 | - 系统弹窗、提示框
16 | - 设备振动
17 | - 加速度计
18 | - 键盘与输入法
19 | - 设备信息、屏幕信息（异形屏幕与安全区检测）
20 | - [更多功能查看接口文档](src/framework/@types/platform.d.ts)
21 | 
22 | ### 支持的平台
23 | - Web 浏览器
24 | - 微信小游戏
25 | - 抖音小游戏（字节系小游戏）
26 | - 快手小游戏
27 | - QQ 小游戏
28 | - VIVO 小游戏
29 | - OPPO 小游戏
30 | 


--------------------------------------------------------------------------------
/src/framework/common/exception.ts:
--------------------------------------------------------------------------------
 1 | class Exception extends Error {
 2 | 	constructor(message?: string, readonly code = 0) {
 3 | 		super(message);
 4 | 	}
 5 | }
 6 | 
 7 | export class NotImplementedException extends Exception {
 8 | 	constructor(message: string = 'Not impemented', readonly code = 0) {
 9 | 		super(message, code);
10 | 	}
11 | }
12 | 
13 | export class NotSupportedException extends Exception {
14 | 	constructor(message: string = 'Not supported', readonly code = 0) {
15 | 		super(message, code);
16 | 	}
17 | }
18 | 
19 | export class OperateFailedException extends Exception {
20 | 	constructor(message: string = 'opertation failed', readonly code = 0) {
21 | 		super(message, code);
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/promise.ts:
--------------------------------------------------------------------------------
 1 | import 'finally-polyfill';
 2 | const actions = {} as Record<string| number, Promise<any> & { refcount: number } >;
 3 | 
 4 | /**
 5 |  * 避免异步请求在执行过程中被多次执行，如果第一次执行没有完成，后续的请求将直接返回正在执行的操作
 6 |  * @param id 用于识别相同操作行为的ID
 7 |  * @param action 真正执行操作的行为
 8 |  */
 9 | export function avoidRepeat<T>(id: string | number, action: ()=> Promise<T>) {
10 | 	let a = actions[id];
11 | 	if (!a) {
12 | 		a = action() as Promise<T> & { refcount: number; };
13 | 		a.refcount = 1;
14 | 		actions[id] = a;
15 | 	} else {
16 | 		a.refcount += 1;
17 | 	}
18 | 	a.finally(() => {
19 | 		a.refcount -= 1;
20 | 		if (a.refcount <= 0) {
21 | 			delete actions[id];
22 | 		}
23 | 	});
24 | 	return a as Promise<T>;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/framework/@types/sdk.d.ts:
--------------------------------------------------------------------------------
 1 | declare interface ISDKClass {
 2 | 	/** SDK 的类型 */
 3 | 	readonly type: string;
 4 | 	/** 启动游戏时被创建 */
 5 | 	new(options?: Record<string, any>): ISDK;
 6 | }
 7 | 
 8 | /** SDK 接口 */
 9 | declare interface ISDK {
10 | 	/** SDK 名称 */
11 | 	readonly name?: string;
12 | 
13 | 	/** 游戏启动时被调用, 需要及时 reslove 否则将阻止游戏启动流程 */
14 | 	initialize?(): Promise<void>;
15 | 
16 | 	/** 游戏结束时被调用 */
17 | 	finalize?(): void;
18 | 
19 | 	/** 游戏开始时调用 */
20 | 	start?(): void;
21 | 
22 | 	/** 上报事件 */
23 | 	sendEvent?(event: string, values?: Record<string, boolean|string|number|null>): Promise<void>;
24 | 
25 | 	/** 用户登陆成功时被调用 */
26 | 	onUserLogin?(user: User): void;
27 | 
28 | 	/** 应用进入前台时调用 */
29 | 	onShow?(): void;
30 | 
31 | 	/** 应用进入后台是调用 */
32 | 	onHide?(): void;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/downloader.web.ts:
--------------------------------------------------------------------------------
 1 | import { XHRFileDownloader } from 'framework/tiny/utils/FileDownloader.xhr';
 2 | import { path } from 'framework/tiny/utils/path';
 3 | 
 4 | export class WebFileDownloader extends XHRFileDownloader {
 5 | 	constructor(readonly fs: IFilesSystem) {
 6 | 		super();
 7 | 	}
 8 | 
 9 | 	protected async saveResponse(request: XMLHttpRequest, task: IDownloadTask, onProgress?: (current: number, max: number) => void): Promise<void> {
10 | 		if (onProgress) onProgress(0, 1);
11 | 		const type = typeof request.response === 'string' ? 'utf8' : 'binary';
12 | 		await this.fs.mkdir(path.dirname(task.file), true);
13 | 		await this.fs.writeFile(task.file, request.response, type as unknown as 'binary');
14 | 		if (onProgress) onProgress(1, 1);
15 | 	}
16 | }
17 | 


--------------------------------------------------------------------------------
/src/framework/@types/IFileDownloader.d.ts:
--------------------------------------------------------------------------------
 1 | declare interface IDownloadTask {
 2 | 	/** 取消下载 */
 3 | 	abort();
 4 | 	/** 下载进度事件 */
 5 | 	onprogress?: (current: number, max: number) => void;
 6 | 	/** 下载完成事件 */
 7 | 	onload?: () => void;
 8 | 	/** 下载出错事件 */
 9 | 	onerror?: (error: any) => void;
10 | 	/** 错误信息 */
11 | 	error?: any;
12 | 	/** 请求的 url */
13 | 	readonly url: string;
14 | 	/** 文件保存的实际路径，注意可能与传入的路径不一致，如添加用户可写路径等操作，需要以返回值的路径为准 */
15 | 	readonly file: string;
16 | }
17 | 
18 | declare interface IDownloadFileOptions {
19 | 	/** 存储类型 */
20 | 	type: 'text' | 'arraybuffer';
21 | 	/** 请求 header */
22 | 	headers?: Record<string, string>;
23 | 	/** 超时时间 单位 ms */
24 | 	timeout?: number;
25 | }
26 | 
27 | declare interface IFileDownloader {
28 | 	load(url: string, file: string, options?: IDownloadFileOptions): IDownloadTask;
29 | }
30 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"compilerOptions": {
 3 | 		"target": "es6",
 4 | 		"module": "ESNext",
 5 | 		"jsx": "preserve",
 6 | 		"lib": [
 7 | 			"DOM",
 8 | 			"ES2020"
 9 | 		],
10 | 		"allowJs": true,
11 | 		"sourceMap": true,
12 | 		"inlineSources": true,
13 | 		"moduleResolution": "node",
14 | 		"baseUrl": "src",
15 | 		"typeRoots": [
16 | 			"node_modules/@types",
17 | 			"Assets/Scripts/gen/puerts/Typing/csharp",
18 | 			"src/types"
19 | 		],
20 | 		"skipLibCheck": true,
21 | 		"noImplicitAny": true,
22 | 		"experimentalDecorators": true,
23 | 		"allowSyntheticDefaultImports": true
24 | 	},
25 | 	"exclude": [
26 | 		"**/*.js",
27 | 		"docs/",
28 | 		"node_modules/",
29 | 		"tiny_modules/",
30 | 		"src/framework/tiny/utils/hash/js-md5.js",
31 | 		"Assets/**/*.mjs",
32 | 		"Library/**/*",
33 | 		"UI/plugins/tiny/**/*"
34 | 	]
35 | }


--------------------------------------------------------------------------------
/src/framework/platform/dev/page/iphonex.html:
--------------------------------------------------------------------------------
 1 | <style>
 2 | .navigator-line {
 3 |     position: fixed;
 4 |     bottom: 10px;
 5 |     background: #000;
 6 |     width: 200px;
 7 |     height: 0.5%;
 8 |     left: 0;
 9 |     right: 0;
10 |     margin: 0 auto;
11 |     border-radius: 1rem !important;
12 |     z-index: 99;
13 | }
14 | </style>
15 | <div id="navigator-line" class="navigator-line" />
16 | 
17 | 
18 | <script>
19 |   window.tinyWebDevTools = window.tinyWebDevTools || {};
20 |   setTimeout(function () {// 延迟一帧执行，因为该脚本在 platform 的构造函数中执行，调用 getPlatform 会导致循环调用
21 |     getPlatform().on('switchDebugOption', function (option, visible) {
22 |       if (option === 'navigator-line') {
23 |         var navigator = document.getElementById('navigator-line');
24 |         if (navigator) {
25 |           navigator.style.display = visible ? 'block' : 'none';
26 |         }
27 |       }
28 |     });
29 |   }, 10);
30 | </script>
31 | 


--------------------------------------------------------------------------------
/src/framework/common/constants.ts:
--------------------------------------------------------------------------------
 1 | export enum PlatformType {
 2 | 	/** 平台类型无法被正确检测 */
 3 | 	Unknown = 'unknown',
 4 | 	/** 原生应用，直接安装到系统不需要借助其他程序就能运行 */
 5 | 	Native = 'native',
 6 | 	/** 原生 - 小米应用市场 */
 7 | 	NativeMi = 'native-mi',
 8 | 
 9 | 	/** 开发环境 */
10 | 	Dev = 'dev',
11 | 	/** 浏览器 */
12 | 	Web = 'web',
13 | 	/** 微信小游戏 */
14 | 	Wechat = 'wechat',
15 | 	/** QQ 小游戏 */
16 | 	QQ = 'qq',
17 | 	/** 字节跳动平台小游戏 */
18 | 	ByteDance = 'bytedance',
19 | 	/** OPPO小游戏 */
20 | 	OPPO = 'oppo',
21 | 	/** VIVO小游戏 */
22 | 	VIVO = 'vivo',
23 | 	/** UC 小游戏 */
24 | 	UC = 'uc',
25 | 	/** 快手小游戏*/
26 | 	KuaiShou = 'kuaishou',
27 | 	/** hago游戏 */
28 | 	Hago = 'hago',
29 | 	/** 安卓原生 */
30 | 	Android = 'android',
31 | 	/** AppStore */
32 | 	iOS = 'iOS',
33 | 	/** 玩吧 */
34 | 	Wanba = 'wanba'
35 | }
36 | 
37 | export enum HostApplicationEvent {
38 | 	FOCUS = 'focus',
39 | 	INFOCUS = 'infocus',
40 | 	VISIABLE = 'visiable',
41 | 	INVISIABLE = 'invisiable',
42 | }
43 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/StateMachine.basic.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from '../core/EventEmitter';
 2 | import { TinyObject } from '../core/TinyObject';
 3 | 
 4 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
 5 | export type BasicStateType = any;
 6 | export type IEventMap<T extends BasicStateType> = {
 7 | 	'state-changed': (next: T, last: T) => void;
 8 | };
 9 | 
10 | 
11 | export class PureBasicStateMachine<T extends BasicStateType> extends TinyObject {
12 | 	readonly event: EventEmitter<IEventMap<T>>;
13 | 
14 | 	constructor(initState?: T) {
15 | 		super();
16 | 		this.$state = initState;
17 | 	}
18 | 
19 | 	get state(): T { return this.$state; }
20 | 	public set state(v: T) { this.setState(v); }
21 | 	protected $state: T;
22 | 
23 | 	protected setState(v: T) {
24 | 		if (v != this.$state) {
25 | 			const last = this.$state;
26 | 			this.$state = v;
27 | 			this.event.emit('state-changed', v, last);
28 | 		}
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/src/framework/@types/recorder.d.ts:
--------------------------------------------------------------------------------
 1 | type RecorderState = 'idle' | 'recording' | 'pause' | 'stop';
 2 | type IRecorderEventMap = {
 3 | 
 4 | 	start(): void;
 5 | 	stop(path?: string): void;
 6 | 
 7 | 	pause(): void;
 8 | 	resume(): void;
 9 | 	error(err: string): void;
10 | 
11 | 	'interruption-begin': () => void;
12 | 	'interruption-end': () => void;
13 | 	'state-changed': (next: RecorderState, last: RecorderState) => void;
14 | };
15 | 
16 | /** 游戏录制器 */
17 | declare interface IGameRecorder extends IEventObject<IRecorderEventMap> {
18 | 
19 | 	/** 当前的状态 */
20 | 	state: RecorderState;
21 | 
22 | 	/**
23 | 	 * 开始录屏
24 | 	 * @param duration 录屏时长（秒）
25 | 	 * @param frameRate 帧率，默认30
26 | 	 */
27 | 	start(duration?: number, frameRate?: number): void;
28 | 
29 | 	/** 停止录屏 */
30 | 	stop(): void;
31 | 
32 | 	/** 暂停 */
33 | 	pause(): void;
34 | 
35 | 	/** 继续录屏 */
36 | 	resume(): void;
37 | 
38 | 	/** 分享录屏 */
39 | 	share(params?: Record<string, any>): Promise<{ videoId: string; }>;
40 | }
41 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/fs/FileUtils.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable @typescript-eslint/no-explicit-any */
 2 | import { path } from '../path';
 3 | 
 4 | export default class FileUtils {
 5 | 
 6 | 	/**
 7 | 	 * 获取目录下的文件列表
 8 | 	 * @param fs 文件系统对象
 9 | 	 * @param dir 目录
10 | 	 * @param recursive 是否递归列出子目录下的文件
11 | 	 * @returns
12 | 	 */
13 | 	static async getFiles(fs: IFilesSystem, dir: string, recursive: boolean = false) {
14 | 		const stat = await fs.stat(dir);
15 | 		if (!stat || !stat.isDirectory()) throw new Error(`${dir} is not a directory`);
16 | 		let files: string[] = [];
17 | 
18 | 		const entries = await fs.readdir(dir);
19 | 		for (const entry of entries) {
20 | 			const res = path.join(dir, entry);
21 | 			const stat = await fs.stat(res);
22 | 			if (stat.isFile()) {
23 | 				files.push(res);
24 | 			} else if (stat.isDirectory() && recursive) {
25 | 				files = files.concat(files, await this.getFiles(fs, res, recursive));
26 | 			}
27 | 		}
28 | 		return files;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 Geequlim
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/websocket.web.ts:
--------------------------------------------------------------------------------
 1 | export class TinyWebSocketW3C implements TinyWebSocket {
 2 | 
 3 | 	protected readonly ws: WebSocket;
 4 | 
 5 | 	onclose: (event: { code: number; reason: string; }) => void;
 6 | 	/** 连接错误时被调用 */
 7 | 	onerror: (event: { code: number; message: string; }) => void;
 8 | 	/** 收到数据时被调用 */
 9 | 	onmessage: (data: string | ArrayBuffer) => void;
10 | 	/** 建立连接后被调用 */
11 | 	onopen: () => null;
12 | 
13 | 	constructor(url: string, protocols?: string | string[]) {
14 | 		this.ws = new WebSocket(url, protocols);
15 | 		this.ws.binaryType = 'arraybuffer';
16 | 		this.ws.onopen = (ev) => {
17 | 			console.log('connectSocket success', url, protocols);
18 | 			this.onopen && this.onopen();
19 | 		};
20 | 		this.ws.onclose = (ev) => {
21 | 			console.log('socketClose', url);
22 | 			this.onclose && this.onclose(ev);
23 | 		};
24 | 		this.ws.onerror = (ev) => this.onerror && this.onerror({ code: -1, message: 'Network error'});
25 | 		this.ws.onmessage = (ev) => this.onmessage && this.onmessage(ev.data);
26 | 	}
27 | 
28 | 	async close(code?: number, reason?: string) {
29 | 		this.ws.close(code, reason);
30 | 	}
31 | 
32 | 	async send(data: string | ArrayBuffer) {
33 | 		this.ws.send(data);
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/src/framework/tiny/core/global.ts:
--------------------------------------------------------------------------------
 1 | declare const global: typeof globalThis;
 2 | declare const self: typeof globalThis;
 3 | declare const window: typeof globalThis;
 4 | 
 5 | // eslint-disable-next-line
 6 | let $globalObject: Record<string, any> = undefined;
 7 | if (typeof globalThis === 'object') $globalObject = globalThis;
 8 | else if (typeof global === 'object') $globalObject = global;
 9 | else if (typeof window === 'object') $globalObject = window;
10 | else if (typeof self === 'object') $globalObject = self;
11 | else $globalObject = {};
12 | 
13 | /** 全局变量对象，兼容多种 JS 运行时环境 */
14 | export const globalObject = $globalObject;
15 | 
16 | /**
17 |  * 设置全局变量
18 |  *
19 |  * @param {string} key 变量名
20 |  * @param {unknown} value 值
21 |  */
22 | export function globalSet(key: string, value: unknown) {
23 | 	try {
24 | 		// @ts-ignore
25 | 		if (typeof GameGlobal === 'object') GameGlobal[key] = value;
26 | 		Object.defineProperty(globalObject, key, { value, enumerable: true, configurable: true, writable: true });
27 | 	} catch (error) {
28 | 		console.error(`定义全局变量 ${key} 失败:`, error);
29 | 	}
30 | }
31 | 
32 | /**
33 |  * 获取全局变量
34 |  *
35 |  * @param {string} key 变量名
36 |  */
37 | export function globalGet(key: string) {
38 | 	return globalObject[key];
39 | }
40 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/deferred.ts:
--------------------------------------------------------------------------------
 1 | // eslint-disable-next-line @typescript-eslint/ban-types
 2 | type DeferredAction = Function;
 3 | type DeferredActionID = DeferredAction | string | number;
 4 | type DeferredActionTask = {
 5 |     readonly startAt: number;
 6 |     timer: ReturnType<typeof setTimeout>;
 7 | };
 8 | const deferredActions = new Map<DeferredActionID, DeferredActionTask>();
 9 | 
10 | /**
11 |  * 延迟调用，如果在延迟期间再次调用，则会取消之前的调用请求
12 |  * @param action 要执行的操作
13 |  * @param durationMs 延迟时间
14 |  * @param maxDelayMs 从第一次请求此操作到最终执行，最大能被推迟多久, 默认没有限制
15 |  * @param id 用于标记相同操作的ID，如果相同ID的操作在延迟期间再次调用，则会取消之前的调用
16 |  * 	- 如果不传`id`，则使用`action`本身作为ID
17 |  */
18 | export function deferred(action: DeferredAction, durationMs: number, maxDelayMs: number = Infinity, id?: DeferredActionID) {
19 |     const uid = id || action;
20 |     let task = deferredActions.get(uid);
21 |     const callback = () => {
22 |         deferredActions.delete(uid); // 这里需要先删除任务再执行，避免任务发生异常导致无法清理
23 |         action();
24 |     };
25 |     if (task) {
26 |         clearTimeout(task.timer);
27 |         const delay = Math.min(durationMs, maxDelayMs - (Date.now() - task.startAt));
28 |         task.timer = setTimeout(callback, delay);
29 |     } else {
30 |         task = {
31 |             startAt: Date.now(),
32 |             timer: setTimeout(callback, durationMs)
33 |         };
34 |         deferredActions.set(uid, task);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "scripts": {
 3 |     "build": "webpack --env entry=all production=true obfuscate=false"
 4 |   },
 5 |   "dependencies": {
 6 |     "@fingerprintjs/fingerprintjs": "^4.6.0",
 7 |     "@types/qs": "^6.9.18",
 8 |     "@types/url-parse": "^1.4.11",
 9 |     "@types/whatwg-mimetype": "^3.0.2",
10 |     "bowser": "^2.11.0",
11 |     "data-uri-to-buffer": "^6.0.2",
12 |     "filesize": "^10.1.6",
13 |     "finally-polyfill": "^0.2.0",
14 |     "http-status-codes": "^2.3.0",
15 |     "javascript-obfuscator": "^4.1.1",
16 |     "localforage": "^1.10.0",
17 |     "qrcode-generator": "^1.4.4",
18 |     "qs": "^6.14.0",
19 |     "safe-area-insets": "^1.4.1",
20 |     "sweetalert2": "^11.17.2",
21 |     "url-parse": "^1.5.10",
22 |     "vconsole": "^3.15.1",
23 |     "whatwg-mimetype": "^4.0.0"
24 |   },
25 |   "devDependencies": {
26 |     "esbuild": "^0.25.0",
27 |     "esbuild-loader": "^4.3.0",
28 |     "fork-ts-checker-webpack-plugin": "^9.0.2",
29 |     "raw-loader": "^4.0.2",
30 |     "ts-loader": "^9.5.2",
31 |     "tsconfig-paths-webpack-plugin": "^4.2.0",
32 |     "typescript": "^5.7.3",
33 |     "util": "^0.12.5",
34 |     "webpack": "^5.98.0",
35 |     "webpack-bundle-analyzer": "^4.10.2",
36 |     "webpack-cli": "^6.0.1",
37 |     "webpack-dev-server": "^5.2.0",
38 |     "webpack-node-externals": "^3.0.0",
39 |     "webpack-obfuscator": "^3.5.1",
40 |     "webpackbar": "^7.0.0",
41 |     "yaml-loader": "^0.8.1"
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/downloader.wechat.ts:
--------------------------------------------------------------------------------
 1 | import { path } from 'framework/tiny/utils/path';
 2 | 
 3 | export class WechatFileDownloader implements IFileDownloader {
 4 | 
 5 | 	constructor(readonly fs: IFilesSystem) { }
 6 | 
 7 | 	load(url: string, file: string, options?: IDownloadFileOptions): IDownloadTask {
 8 | 		const task: IDownloadTask = { url, file, abort: null };
 9 | 		let maxSize = 0;
10 | 		let timerID = 0 as unknown as ReturnType<typeof setTimeout>;
11 | 		const clear = () => clearTimeout(timerID);
12 | 		const wxTask = wx.downloadFile({
13 | 			url,
14 | 			header: options?.headers,
15 | 			success: async (ret) => {
16 | 				clear();
17 | 				try {
18 | 					const filePath = file;
19 | 					await this.fs.mkdir(path.dirname(filePath), true);
20 | 					await this.fs.copyFile(ret.tempFilePath, filePath);
21 | 					(task.file as string) = filePath;
22 | 					if (task.onprogress) task.onprogress(maxSize, maxSize);
23 | 					if (task.onload) task.onload();
24 | 				} catch (error) {
25 | 					task.error = error;
26 | 					if (task.onerror) task.onerror(error);
27 | 				}
28 | 			},
29 | 			fail(err) {
30 | 				clear();
31 | 				task.error = err;
32 | 				if (task.onerror) task.onerror(err);
33 | 			}
34 | 		});
35 | 		if (options?.timeout) {
36 | 			timerID = setTimeout(() => {
37 | 				wxTask.abort();
38 | 				task.error = new Error('timeout');
39 | 			}, options.timeout);
40 | 		}
41 | 		wxTask.onProgressUpdate(progress => {
42 | 			maxSize = progress.totalBytesExpectedToWrite;
43 | 			if (task.onprogress) task.onprogress(progress.totalBytesWritten, progress.totalBytesExpectedToWrite);
44 | 		});
45 | 		task.abort = () => wxTask.abort();
46 | 		return task;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/downloader.bytedance.ts:
--------------------------------------------------------------------------------
 1 | import { path } from 'framework/tiny/utils/path';
 2 | 
 3 | export class BytedanceFileDownloader implements IFileDownloader {
 4 | 
 5 | 	constructor(readonly fs: IFilesSystem) { }
 6 | 
 7 | 	load(url: string, file: string, options?: IDownloadFileOptions): IDownloadTask {
 8 | 		const task: IDownloadTask = { url, file, abort: null };
 9 | 		let maxSize = 0;
10 | 		let timerID = 0 as unknown as ReturnType<typeof setTimeout>;
11 | 		const clear = () => clearTimeout(timerID);
12 | 		const ttTask = tt.downloadFile({
13 | 			url,
14 | 			header: options?.headers,
15 | 			success: async (ret) => {
16 | 				clear();
17 | 				try {
18 | 					const filePath = file;
19 | 					await this.fs.mkdir(path.dirname(filePath), true);
20 | 					await this.fs.copyFile(ret.tempFilePath, filePath);
21 | 					(task.file as string) = filePath;
22 | 					if (task.onprogress) task.onprogress(maxSize, maxSize);
23 | 					if (task.onload) task.onload();
24 | 				} catch (error) {
25 | 					task.error = error;
26 | 					task.onerror && task.onerror(error);
27 | 				}
28 | 			},
29 | 			fail(err) {
30 | 				clear();
31 | 				task.error = err;
32 | 				task.onerror && task.onerror(err);
33 | 			}
34 | 		});
35 | 		if (options?.timeout) {
36 | 			timerID = setTimeout(() => {
37 | 				ttTask.abort();
38 | 				task.error = new Error('timeout');
39 | 			}, options.timeout);
40 | 		}
41 | 		ttTask.onProgressUpdate(progress => {
42 | 			maxSize = progress.totalBytesExpectedToWrite;
43 | 			if (task.onprogress) task.onprogress(progress.totalBytesWritten, progress.totalBytesExpectedToWrite);
44 | 		});
45 | 		task.abort = () => ttTask.abort();
46 | 		return task;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/downloader.kuaishou.ts:
--------------------------------------------------------------------------------
 1 | import { path } from 'framework/tiny/utils/path';
 2 | 
 3 | export class KuaishouFileDownloader implements IFileDownloader {
 4 | 
 5 | 	constructor(readonly fs: IFilesSystem) { }
 6 | 
 7 | 	load(url: string, file: string, options?: IDownloadFileOptions): IDownloadTask {
 8 | 		const task: IDownloadTask = { url, file, abort: null };
 9 | 		let maxSize = 0;
10 | 		let timerID = 0 as unknown as ReturnType<typeof setTimeout>;
11 | 		const clear = () => clearTimeout(timerID);
12 | 		const wxTask = ks.downloadFile({
13 | 			url,
14 | 			header: options?.headers,
15 | 			success: async (ret) => {
16 | 				clear();
17 | 				try {
18 | 					const filePath = file;
19 | 					await this.fs.mkdir(path.dirname(filePath), true);
20 | 					await this.fs.copyFile(ret.tempFilePath, filePath);
21 | 					(task.file as string) = filePath;
22 | 					if (task.onprogress) task.onprogress(maxSize, maxSize);
23 | 					if (task.onload) task.onload();
24 | 				} catch (error) {
25 | 					task.error = error;
26 | 					if (task.onerror) task.onerror(error);
27 | 				}
28 | 			},
29 | 			fail(err) {
30 | 				clear();
31 | 				task.error = err;
32 | 				if (task.onerror) task.onerror(err);
33 | 			}
34 | 		});
35 | 		if (options?.timeout) {
36 | 			timerID = setTimeout(() => {
37 | 				wxTask.abort();
38 | 				task.error = new Error('timeout');
39 | 			}, options.timeout);
40 | 		}
41 | 		wxTask.onProgressUpdate(progress => {
42 | 			maxSize = progress.totalBytesExpectedToWrite;
43 | 			if (task.onprogress) task.onprogress(progress.totalBytesWritten, progress.totalBytesExpectedToWrite);
44 | 		});
45 | 		task.abort = () => wxTask.abort();
46 | 		return task;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/src/framework/@types/fs.d.ts:
--------------------------------------------------------------------------------
 1 | declare type FileEncoding = 'utf8' | 'binary';
 2 | declare type Stat = {
 3 | 	/** 文件字节大小，未必可靠，实现中如果平台不支持应返回`1` */
 4 | 	size: number;
 5 | 	/** 文件最后修改时间，未必可靠，实现中如果平台不支持应返回`0` */
 6 | 	lastModifiedTime: number;
 7 | 	/** 是否是文件，未必可靠，实现中如果平台不支持应返回`true` */
 8 | 	isFile(): boolean;
 9 | 	/** 是否是目录，未必可靠，实现中如果平台不支持应返回`false` */
10 | 	isDirectory(): boolean;
11 | };
12 | 
13 | /** 只读文件系统 */
14 | declare interface IReadonlyFilesSystem {
15 | 
16 | 	exists(filePath: string): Promise<boolean>;
17 | 	existsSync(filePath: string): boolean;
18 | 
19 | 	stat(filePath: string): Promise<Stat>;
20 | 	statSync(filePath: string): Stat;
21 | 
22 | 	readdir(dirPath: string): Promise<string[]>;
23 | 
24 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
25 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
26 | }
27 | 
28 | declare interface ISyncReadonlyFilesSystem {
29 | 	existsSync(filePath: string): boolean;
30 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
31 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
32 | }
33 | 
34 | /** 文件系统 */
35 | declare interface IFilesSystem extends IReadonlyFilesSystem {
36 | 
37 | 	unlink(filePath: string): Promise<void>;
38 | 	rename(oldPath: string, newPath: string): Promise<void>;
39 | 	mkdir(dirPath: string, recursive: boolean): Promise<void>;
40 | 
41 | 	copyFile(src: string, dist: string): Promise<void>;
42 | 
43 | 	rmdir(dirPath: string, recursive: boolean): Promise<void>;
44 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
45 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
46 | 
47 | 	clear?: () => Promise<void>;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/fs/fs.xhr.ts:
--------------------------------------------------------------------------------
 1 | import { path } from '../path';
 2 | 
 3 | export class XHRFileSystem implements IReadonlyFilesSystem {
 4 | 
 5 | 	constructor(readonly root: string) {}
 6 | 
 7 | 	exists(filePath: string): Promise<boolean> {
 8 | 		throw new Error('Method not implemented.');
 9 | 	}
10 | 
11 | 	existsSync(filePath: string): boolean {
12 | 		throw new Error('Method not implemented.');
13 | 	}
14 | 
15 | 	stat(filePath: string): Promise<Stat> {
16 | 		throw new Error('Method not implemented.');
17 | 	}
18 | 
19 | 	statSync(filePath: string): Stat {
20 | 		throw new Error('Method not implemented.');
21 | 	}
22 | 
23 | 	readdir(dirPath: string): Promise<string[]> {
24 | 		throw new Error('Method not implemented.');
25 | 	}
26 | 
27 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
28 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
29 | 	readFile(filePath: unknown, encoding: unknown): Promise<string | ArrayBuffer> {
30 | 		const url = this.root ? path.join(this.root, filePath as string) : filePath as string;
31 | 		return new Promise((resolve, reject) => {
32 | 			const request = new XMLHttpRequest();
33 | 			request.responseType = encoding === 'binary' ? 'arraybuffer' : 'text';
34 | 			request.onload = () => {
35 | 				if (request.status >= 400) {
36 | 					reject(request.response || { url: url, code: request.status, message: 'Network error' });
37 | 					return;
38 | 				}
39 | 				resolve(request.response);
40 | 			};
41 | 			request.onerror = () => {
42 | 				reject(request.response || { url: url, code: request.status, message: 'Network error' });
43 | 			};
44 | 			request.ontimeout = () => reject(request.response || { url, code: -2, message: 'Request timeout' });
45 | 			request.open('GET', url);
46 | 			request.send();
47 | 		});
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/websocket.wechat.ts:
--------------------------------------------------------------------------------
 1 | export class WechatWebSocket implements TinyWebSocket {
 2 | 
 3 | 	protected ws: wx.SocketTask;
 4 | 
 5 | 	onclose: (event: { code: number; reason: string; }) => void;
 6 | 	/** 连接错误时被调用 */
 7 | 	onerror: (event: { code: number; message: string; }) => void;
 8 | 	/** 收到数据时被调用 */
 9 | 	onmessage: (data: string | ArrayBuffer) => void;
10 | 	/** 建立连接后被调用 */
11 | 	onopen: () => null;
12 | 
13 | 	constructor(url: string, protocols?: string | string[]) {
14 | 		this.ws = wx.connectSocket({
15 | 			url,
16 | 			protocols: protocols ? (Array.isArray(protocols) ? protocols : [protocols]) : [],
17 | 			success: () => {
18 | 			},
19 | 			fail: (err: { errMsg: string; }) => {
20 | 				this.onerror && this.onerror({ code: -1, message: err.errMsg });
21 | 			}
22 | 		});
23 | 		this.ws.onOpen((ev) => {
24 | 			console.log('ws.onOpen', url, this.onopen);
25 | 			this.onopen && this.onopen();
26 | 		});
27 | 		this.ws.onClose((ev) => {
28 | 			console.log('ws.onClose', url, this.onclose);
29 | 			this.onclose && this.onclose(ev);
30 | 		});
31 | 		this.ws.onError((ev) => {
32 | 			console.error('ws.onError', url, this.onclose);
33 | 			this.onerror && this.onerror({ code: -1, message: 'Network error' });
34 | 		});
35 | 		this.ws.onMessage((ev) => this.onmessage && this.onmessage(ev.data));
36 | 	}
37 | 
38 | 	close(code?: number, reason?: string) {
39 | 		return new Promise<void>((resolve, reject) => {
40 | 			this.ws.close({ code, reason, success: resolve, fail: reject });
41 | 		});
42 | 	}
43 | 
44 | 	send(data: string | ArrayBuffer) {
45 | 		return new Promise<void>((resolve, reject) => {
46 | 			this.ws.send({
47 | 				data,
48 | 				success: resolve,
49 | 				fail: (err) => {
50 | 					this.onerror && this.onerror({ code: -1, message: err.errMsg });
51 | 					reject(err);
52 | 				}
53 | 			});
54 | 		});
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/websocket.kuaishou.ts:
--------------------------------------------------------------------------------
 1 | export class KuaiShouWebSocket implements TinyWebSocket {
 2 | 
 3 | 	protected ws: ks.SocketTask;
 4 | 
 5 | 	onclose: (event: { code: number; reason: string; }) => void;
 6 | 	/** 连接错误时被调用 */
 7 | 	onerror: (event: { code: number; message: string; }) => void;
 8 | 	/** 收到数据时被调用 */
 9 | 	onmessage: (data: string | ArrayBuffer) => void;
10 | 	/** 建立连接后被调用 */
11 | 	onopen: () => null;
12 | 
13 | 	constructor(url: string, protocols?: string | string[]) {
14 | 		this.ws = ks.connectSocket({
15 | 			url,
16 | 			protocols: protocols ? (Array.isArray(protocols) ? protocols : [protocols]) : [],
17 | 			success: () => {
18 | 			},
19 | 			fail: (err: { errMsg: string; }) => {
20 | 				this.onerror && this.onerror({ code: -1, message: err.errMsg });
21 | 			}
22 | 		});
23 | 		this.ws.onOpen((ev) => {
24 | 			console.log('ks.onOpen', url, typeof this.onopen);
25 | 			this.onopen && this.onopen();
26 | 		});
27 | 		this.ws.onClose((ev) => {
28 | 			console.log('ks.onClose', url, typeof this.onclose);
29 | 			this.onclose && this.onclose(ev);
30 | 		});
31 | 		this.ws.onError((ev) => {
32 | 			console.error('ks.onError', url, typeof this.onerror);
33 | 			this.onerror && this.onerror({ code: -1, message: 'Network error' });
34 | 		});
35 | 		this.ws.onMessage((ev) => this.onmessage && this.onmessage(ev.data));
36 | 	}
37 | 
38 | 	close(code?: number, reason?: string) {
39 | 		return new Promise<void>((resolve, reject) => {
40 | 			this.ws.close({ code, reason, success: resolve, fail: reject });
41 | 		});
42 | 	}
43 | 
44 | 	send(data: string | ArrayBuffer) {
45 | 		return new Promise<void>((resolve, reject) => {
46 | 			this.ws.send({
47 | 				data,
48 | 				success: resolve,
49 | 				fail: (err) => {
50 | 					this.onerror && this.onerror({ code: -1, message: err.errMsg });
51 | 					reject(err);
52 | 				}
53 | 			});
54 | 		});
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/websocket.bytedance.ts:
--------------------------------------------------------------------------------
 1 | export class BytedanceWebSocket implements TinyWebSocket {
 2 | 
 3 | 	protected ws: tt.SocketTask;
 4 | 
 5 | 	onclose: (event: { code: number; reason: string; }) => void;
 6 | 	/** 连接错误时被调用 */
 7 | 	onerror: (event: { code: number; message: string; }) => void;
 8 | 	/** 收到数据时被调用 */
 9 | 	onmessage: (data: string | ArrayBuffer) => void;
10 | 	/** 建立连接后被调用 */
11 | 	onopen: () => null;
12 | 
13 | 	constructor(url: string, protocols?: string | string[]) {
14 | 		this.ws = tt.connectSocket({
15 | 			url,
16 | 			protocols: protocols ? (Array.isArray(protocols) ? protocols : [protocols]) : [],
17 | 			success: () => {
18 | 			},
19 | 			fail: (err: { errMsg: string; }) => {
20 | 				this.onerror && this.onerror({ code: -1, message: err.errMsg });
21 | 			}
22 | 		});
23 | 		this.ws.onOpen((ev) => {
24 | 			console.log('tt.onOpen', url, typeof this.onopen);
25 | 			this.onopen && this.onopen();
26 | 		});
27 | 		this.ws.onClose((ev) => {
28 | 			console.log('tt.onClose', url, typeof this.onclose);
29 | 			this.onclose && this.onclose(ev);
30 | 		});
31 | 		this.ws.onError((ev) => {
32 | 			console.error('tt.onError', url, typeof this.onerror);
33 | 			this.onerror && this.onerror({ code: -1, message: 'Network error' });
34 | 		});
35 | 		this.ws.onMessage((ev) => this.onmessage && this.onmessage(ev.data));
36 | 	}
37 | 
38 | 	close(code?: number, reason?: string) {
39 | 		return new Promise<void>((resolve, reject) => {
40 | 			this.ws.close({ code, reason, success: resolve, fail: reject });
41 | 		});
42 | 	}
43 | 
44 | 	send(data: string | ArrayBuffer) {
45 | 		return new Promise<void>((resolve, reject) => {
46 | 			this.ws.send({
47 | 				data,
48 | 				success: resolve,
49 | 				fail: (err) => {
50 | 					this.onerror && this.onerror({ code: -1, message: err.errMsg });
51 | 					reject(err);
52 | 				}
53 | 			});
54 | 		});
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/src/framework/@types/env.d.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable @typescript-eslint/no-explicit-any */
 2 | /* eslint-disable @typescript-eslint/no-unused-vars */
 3 | // @ts-ignore
 4 | declare module globalThis {
 5 | 	declare interface ISubPackage {
 6 | 		name: string,
 7 | 		root: string;
 8 | 		priority?: 'bootstrap' | 'required' | 'optional';
 9 | 	}
10 | 
11 | 	type ITinyLibrary = { name: string, root: string, 'minify-ignore'?: boolean };
12 | 
13 | 	declare interface ISubPackageLoadTask {
14 | 		onProgressUpdate?: (callback: (res: {
15 | 			progress: number;
16 | 			totalBytesWritten: number;
17 | 			totalBytesExpectedToWrite: number;
18 | 		}) => void) => void;
19 | 	}
20 | 
21 | 	declare const config: {
22 | 		/** 项目名称 */
23 | 		name: string,
24 | 		/** 调试开关 */
25 | 		debug: boolean,
26 | 		/** 调试地址 */
27 | 		debugUrl: string;
28 | 		/** 平台名称 */
29 | 		platform: string,
30 | 		/** 渠道名称 */
31 | 		channel?: string,
32 | 		/** 分包配置 */
33 | 		subpackages?: ISubPackage[];
34 | 		/** 啰嗦模式 */
35 | 		verbose?: boolean;
36 | 		/** 分包加载器 */
37 | 		subpackage_loader?: (options: { name: string; success?(): void; fail?(err: string); }) => ISubPackageLoadTask;
38 | 		/** 配置要加载的依赖库 */
39 | 		libs: ITinyLibrary[];
40 | 		/** 资源信息 */
41 | 		resource?: {
42 | 			/** 资源根路径 */
43 | 			root_url?: string;
44 | 			/** 资源版本 */
45 | 			version?: string;
46 | 		},
47 | 		/** 包内资源清单 */
48 | 		assets?: {
49 | 			/** 生成时间 */
50 | 			time: number;
51 | 			/** 资源列表 */
52 | 			files: Readonly<Record<string, {
53 | 				/** 文件大小 */
54 | 				size: number;
55 | 				/** 最终修改时间 */
56 | 				mtime: number;
57 | 				/** MD5 值 */
58 | 				md5: string;
59 | 			}>>;
60 | 		};
61 | 	};
62 | 
63 | 	/** 已经引入的库 */
64 | 	declare const libs: {
65 | 		[key: string]: any;
66 | 	};
67 | 	declare function load_script(url: string, callback: (value: unknown) => void, errorCallback: (err?: any) => void): void;
68 | 	declare function loadScriptsOneByOne( libs: string[], onload: ()=> void, onerror: (err: any)=> void): void;
69 | }
70 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/FileDownloader.xhr.ts:
--------------------------------------------------------------------------------
 1 | export class XHRFileDownloader implements IFileDownloader {
 2 | 
 3 | 	load(url: string, file: string, options?: IDownloadFileOptions): IDownloadTask {
 4 | 		const request = new XMLHttpRequest();
 5 | 		request.responseType = options?.type === 'text' ? 'text' : 'arraybuffer';
 6 | 		const task: IDownloadTask = {
 7 | 			url,
 8 | 			file,
 9 | 			abort: () => request.abort(),
10 | 		};
11 | 		if (typeof options?.headers === 'object') {
12 | 			for (const key of Object.getOwnPropertyNames(options.headers)) {
13 | 				request.setRequestHeader(key, options.headers[key]);
14 | 			}
15 | 		}
16 | 		request.timeout = options?.timeout;
17 | 		request.onload = () => {
18 | 			if (request.status >= 400) {
19 | 				task.error = request.response || { url, code: request.status, message: 'Network error' };
20 | 				if (task.onerror) task.onerror(task.error);
21 | 				return;
22 | 			}
23 | 			this.saveResponse(request, task).then(() => {
24 | 				if (task.onload) {
25 | 					task.onload();
26 | 				}
27 | 			}).catch(err => {
28 | 				task.error = err;
29 | 				if (task.onerror) task.onerror(err);
30 | 			});
31 | 		};
32 | 		request.onprogress = (ev) => {
33 | 			if (task.onprogress) {
34 | 				task.onprogress(ev.loaded, ev.total);
35 | 			}
36 | 		};
37 | 		request.onerror = () => {
38 | 			task.error = request.response || { url, code: request.status, message: 'Network error' };
39 | 			if (task.onerror) task.onerror(task.error);
40 | 		};
41 | 		request.onabort = () => task.error = { url, code: -1, message: 'Request abort' };
42 | 		request.ontimeout = () => task.error = { url, code: -2, message: 'Request timeout' };
43 | 		request.open('GET', url);
44 | 		request.send();
45 | 		return task;
46 | 	}
47 | 
48 | 	protected saveResponse(request: XMLHttpRequest, task: IDownloadTask, onProgress?: (current: number, max: number) => void): Promise<void> {
49 | 		if (onProgress) {
50 | 			onProgress(0, 1);
51 | 			onProgress(1, 1);
52 | 		}
53 | 		return Promise.resolve();
54 | 	}
55 | 
56 | }
57 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/format.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | export function numberFormat(num: number): string {
 3 |     const param = { value: '', unit: '' };
 4 |     const k = 10000;
 5 |     const sizes = ['', '万', '亿', '万亿'];
 6 |     let i = 0;
 7 |     if (num < k) {
 8 |         param.value = Math.round(num).toString();
 9 |         param.unit = '';
10 |     } else {
11 |         i = Math.floor(Math.log(num) / Math.log(k));
12 |         param.value = ((num / Math.pow(k, i))).toFixed(2);
13 |         const strs: string[] = param.value.split('.');
14 |         if (strs.length >= 2) {
15 |             strs[1] = strs[1].substr(0, strs[1][1] == '0' ? (strs[1][0] == '0' ? 0 : 1) : 2);
16 |             if (strs[1] != '') param.value = strs[0] + '.' + strs[1];
17 |             else param.value = strs[0];
18 |         }
19 |         param.unit = sizes[i];
20 |     }
21 |     return param.value + param.unit;
22 | }
23 | 
24 | export function numberFormatWan(num: number): string {
25 |     const param = { value: '', unit: '' };
26 |     const k = 10000;
27 |     const sizes = ['', '万'];
28 |     if (num < k) {
29 |         param.value = Math.round(num).toString();
30 |         param.unit = sizes[0];
31 |     } else {
32 |         const value = num / k;
33 |         if (num % k == 0) {
34 |             param.value = value.toString();
35 |         } else {
36 |             param.value = value.toFixed(2).toString();
37 |         }
38 |         param.unit = sizes[1];
39 |     }
40 |     return param.value + param.unit;
41 | }
42 | 
43 | export function numberFormatKM(num: number, fixed: number = 2): string {
44 |     const param = { value: '', unit: '' };
45 |     const k = 1000;
46 |     const sizes = ['', 'k', 'm', 'b', 't', 'q', 'w'];
47 |     if (num < k) {
48 |         param.value = Math.round(num).toString();
49 |         param.unit = sizes[0];
50 |     } else {
51 |         const value = num / k;
52 |         if (num % k == 0) {
53 |             param.value = value.toString();
54 |         } else {
55 |             param.value = value.toFixed(fixed).toString();
56 |         }
57 |         param.unit = sizes[1];
58 |     }
59 |     return param.value + param.unit;
60 | }
61 | 


--------------------------------------------------------------------------------
/src/framework/@types/global.d.ts:
--------------------------------------------------------------------------------
 1 | /** 发布模式构建时为`true` */
 2 | declare const PRODUCTION: boolean;
 3 | /** 构建时间戳 */
 4 | declare const BUILD_TIME: number;
 5 | /** 构建设备的局域网 IPv4 地址 */
 6 | declare const BUILD_LOCAL_HOST: string;
 7 | /** 资源版本 */
 8 | declare const RESOURCE_VERSION: string;
 9 | /** 构建指令中传过来的覆盖配置 */
10 | declare const OVERRIDE_OPTIONS: Record<string, any>;
11 | 
12 | declare type PartialRecord<K extends string | number | symbol, V> = Partial<Record<K, V>>;
13 | 
14 | /** 提取 Promise 的返回值 */
15 | declare type Resolve<T> = T extends PromiseLike<infer U> ? U : T;
16 | /** 提取异步函数的返回值 */
17 | declare type Await<T extends (...args: any[]) => PromiseLike<any>> = Resolve<ReturnType<T>>;
18 | 
19 | declare interface Function {
20 | 	/**
21 | 	 * For a given function, creates a bound function that has the same body as the original function.
22 | 	 * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
23 | 	 * @param thisArg The object to be used as the this object.
24 | 	 * @param args Arguments to bind to the parameters of the function.
25 | 	 */
26 | 	bind<T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
27 | 	bind<T, A0, A extends any[], R>(this: (this: T, arg0: A0, ...args: A) => R, thisArg: T, arg0: A0): (...args: A) => R;
28 | 	bind<T, A0, A1, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1): (...args: A) => R;
29 | 	bind<T, A0, A1, A2, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2): (...args: A) => R;
30 | 	bind<T, A0, A1, A2, A3, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3): (...args: A) => R;
31 | 	bind<T, AX, R>(this: (this: T, ...args: AX[]) => R, thisArg: T, ...args: AX[]): (...args: AX[]) => R;
32 | }
33 | 
34 | /** 翻译文本 */
35 | declare function tr(text: string, values?: Record<string, unknown>, context?: string, lang?: string): string;
36 | 
37 | /** 微信小游戏的全局对象 */
38 | declare const GameGlobal: {};
39 | /** 应用的启动时间戳 */
40 | declare const launchAt: number;
41 | 


--------------------------------------------------------------------------------
/src/framework/@types/EventEmitter.d.ts:
--------------------------------------------------------------------------------
 1 | interface EventMap {
 2 | 	[key: string]: EventHandler;
 3 | }
 4 | 
 5 | interface HandlerOptions {
 6 | 	/** 只执行一次 */
 7 | 	once?: boolean;
 8 | 	/** 阻止后面的回调被派发 */
 9 | 	block?: boolean;
10 | }
11 | 
12 | declare interface IEventEmitter<T extends EventMap> {
13 | 	/**
14 | 	 * 添加事件监听器
15 | 	 *
16 | 	 * @param {EventType} type 事件类型
17 | 	 * @param {EventHandler} handler 事件回调
18 | 	 * @param {boolean} [options] 派发一次事件后移除该事件
19 | 	 * @returns 返回绑定的回调函数，可用于取消绑定
20 | 	 * @memberof EventEmitter
21 | 	 */
22 | 	on<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void, options?: HandlerOptions): void;
23 | 
24 | 	/**
25 | * 添加事件监听器, 事件派发后自动解绑
26 | *
27 | * @param {EventType} type 事件类型
28 | * @param {EventHandler} handler 事件回调
29 | * @param {boolean} [options] 派发一次事件后移除该事件
30 | * @returns 返回绑定的回调函数，可用于取消绑定
31 | * @returns EventEmitter
32 | */
33 | 	once<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void, options?: HandlerOptions): void;
34 | 
35 | 
36 | 	/**
37 | 	 * 转发事件
38 | 	 * @param target 目标代理对象
39 | 	 * @param type 时间类型
40 | 	 * @param options 配置参数
41 | 	 * @returns 返回代理回调，可用于取消转发
42 | 	 */
43 | 	pipe<T2 extends EventMap>(target: EventEmitter<T2>, type: keyof (T | T2), options?: HandlerOptions): () => void;
44 | 
45 | 	/**
46 | 	 * 移除事件监听器
47 | 	 *
48 | 	 * @param {EventType} type 事件类型
49 | 	 * @param {EventHandler} handler 要移除的回调
50 | 	 * @memberof EventEmitter
51 | 	 */
52 | 	off<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void): void;
53 | 
54 | 	/**
55 | 	 * 移除特定类型是所有事件监听器
56 | 	 *
57 | 	 * @param {EventType} type 事件类型，传入`*`则清理所有类型的事件回调
58 | 	 * @memberof EventEmitter
59 | 	 */
60 | 	offAll<K extends keyof T>(type: K | '*'): void;
61 | 
62 | 
63 | 	/**
64 | 	 * 派发事件
65 | 	 *
66 | 	 * @param {EventType} type 事件类型
67 | 	 * @param {...any[]} args 派发参数表
68 | 	 * @memberof EventEmitter
69 | 	 */
70 | 	emit<K extends keyof T>(type: K, ...args: Parameters<T[K]>): void;
71 | 
72 | 	/** 等待事件派发 */
73 | 	wait<K extends keyof T>(event: K): Promise<unknown[]>;
74 | 
75 | 	/** 销毁时解绑所有事件 */
76 | 	dispose(): void;
77 | }
78 | 
79 | declare interface IEventObject<T extends EventMap> {
80 | 	/** 事件派发器 */
81 | 	readonly event: IEventEmitter<T>;
82 | }
83 | 


--------------------------------------------------------------------------------
/src/framework/platform/dev/recorder.dev.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable @typescript-eslint/no-explicit-any */
 2 | import { EventEmitter } from 'framework/tiny/core/EventEmitter';
 3 | import { PureBasicStateMachine } from 'framework/tiny/utils/StateMachine.basic';
 4 | 
 5 | export interface DevShareParams {
 6 | 	/** 分享模板 ID */
 7 | 	templateId?: string;
 8 | 	/** 标题 */
 9 | 	title: string;
10 | 	/** 文字内容 */
11 | 	desc?: string;
12 | 	/** 图片地址 */
13 | 	imageUrl?: string;
14 | 	/** 视频话题(仅抖音支持) ，目前由 hashtag_list 代替，为保证兼容性，建议同时填写两个。 */
15 | 	videoTopics?: string[];
16 | 	/** 生成输入的默认文案 */
17 | 	video_title?: string;
18 | 	/** 视频话题(仅抖音支持) */
19 | 	hashtag_list?: string[];
20 | 	/** 抖音 pgc 音乐的短链(仅抖音支持，需要基础库版本大于 1.90) 。形如 https://v.douyin.com/JmcxWo8/， 参考 抖音小游戏录屏带配乐能力 */
21 | 	defaultBgm?: string;
22 | 	/** 分享视频的标签，可以结合获取抖音视频排行榜使用 */
23 | 	videoTag?: string;
24 | }
25 | 
26 | export class DevGameRecorder extends PureBasicStateMachine<RecorderState> implements IGameRecorder {
27 | 	readonly event: EventEmitter<IRecorderEventMap>;
28 | 	readonly lastRecordVideoId: number;
29 | 	public get recordSharedCount(): number { return this.$recordSharedCount; }
30 | 	protected $recordSharedCount: number;
31 | 
32 | 	/**
33 | 	 * 开始录屏
34 | 	 * @param duration 录屏时长（秒）
35 | 	 * @param frameRate 帧率，默认30
36 | 	 */
37 | 	start(duration: number, frameRate: number = 30) {
38 | 		this.state = 'recording';
39 | 	}
40 | 
41 | 	/** 停止录屏 */
42 | 	stop() {
43 | 		this.state = 'stop';
44 | 	}
45 | 
46 | 	/** 暂停 */
47 | 	pause() {
48 | 		this.state = 'pause';
49 | 	}
50 | 
51 | 	/** 继续录屏 */
52 | 	resume() {
53 | 		this.state = 'recording';
54 | 	}
55 | 
56 | 	/** 分享录屏 */
57 | 	async share(params: DevShareParams = { title: '测试' }): Promise<{ videoId: string; }> {
58 | 		const extra = {
59 | 			withVideoId: true,
60 | 		};
61 | 		for (const key of ['videoTopics', 'video_title', 'hashtag_list', 'defaultBgm', 'videoTag']) {
62 | 			// @ts-ignore
63 | 			if (params[key]) extra[key] = params[key];
64 | 		}
65 | 		const value = {
66 | 			title: params.title,
67 | 			desc: params.desc,
68 | 			imageUrl: params.imageUrl,
69 | 			templateId: params.templateId,
70 | 			channel: 'video',
71 | 			extra
72 | 		};
73 | 		console.log('模拟分享录屏', value);
74 | 		try {
75 | 			await getPlatform().accept('选择分享录屏的结果', '模拟录屏分享', '分享成功', '取消分享');
76 | 		} catch (error) {
77 | 			throw new Error('取消视频分享');
78 | 		}
79 | 		return { videoId: undefined };
80 | 	}
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/recorder.kuaishou.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from 'framework/tiny/core/EventEmitter';
 2 | import { PureBasicStateMachine } from 'framework/tiny/utils/StateMachine.basic';
 3 | 
 4 | export class KuaishouGameRecorder extends PureBasicStateMachine<RecorderState> implements IGameRecorder {
 5 | 	readonly event: EventEmitter<IRecorderEventMap>;
 6 | 	readonly lastRecordVideoId: number;
 7 | 	public get recordSharedCount(): number { return this.$recordSharedCount; }
 8 | 	protected $recordSharedCount: number;
 9 | 
10 | 	readonly native = ks.getGameRecorder();
11 | 	constructor() {
12 | 		super('idle');
13 | 		this.native.on('start', () => {
14 | 			this.state = 'recording';
15 | 			this.event.emit('start');
16 | 		});
17 | 		this.native.on('stop', res => {
18 | 			this.state = 'stop';
19 | 			(this.lastRecordVideoId as number) = res.videoID;
20 | 			this.event.emit('stop');
21 | 		});
22 | 		this.native.on('pause', () => {
23 | 			this.state = 'pause';
24 | 			this.event.emit('pause');
25 | 		});
26 | 		this.native.on('resume', () => {
27 | 			this.state = 'recording';
28 | 			this.event.emit('resume');
29 | 		});
30 | 		this.native.on('error', err => {
31 | 			this.state = 'idle';
32 | 			this.event.emit('error', err.msg);
33 | 		});
34 | 		this.native.on('abort', () => {
35 | 			this.state = 'idle';
36 | 			this.event.emit('interruption-end');
37 | 		});
38 | 	}
39 | 
40 | 	/**
41 | 	 * 开始录屏
42 | 	 * @param duration 录屏时长（秒）
43 | 	 * @param frameRate 帧率，默认30
44 | 	 */
45 | 	start(duration: number, frameRate: number = 30) {
46 | 		this.native.start();
47 | 	}
48 | 
49 | 	/** 停止录屏 */
50 | 	async stop() {
51 | 		await this.native.stop();
52 | 	}
53 | 
54 | 	/** 暂停 */
55 | 	async pause() {
56 | 		await this.native.pause();
57 | 	}
58 | 
59 | 	/** 继续录屏 */
60 | 	async resume() {
61 | 		await this.native.resume();
62 | 	}
63 | 
64 | 	/** 分享录屏 */
65 | 	share(params: { templateId?: string, query?: Record<string, any> } = {}): Promise<{ videoId: string; }> {
66 | 		return new Promise((resolve, reject) => {
67 | 			this.native.publishVideo({
68 | 				video: this.lastRecordVideoId,
69 | 				mouldId: params.templateId || undefined,
70 | 				query: params.query ? JSON.stringify(params.query) : undefined,
71 | 				callback: (err) => {
72 | 					if (err) {
73 | 						reject(new Error(`发布视频出错：${err.code} ${err.msg}`));
74 | 					} else {
75 | 						resolve({ videoId: undefined });
76 | 					}
77 | 				}
78 | 			});
79 | 		});
80 | 	}
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/path.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * 对文件路径的一些操作，针对的是 C:/A/B/C/D/example.ts这种格式
 3 |  */
 4 | export const path = {
 5 | 
 6 | 	/**
 7 | 	 * 格式化文件路径，"C:/A/B//C//D//example.ts"=>"C:/A/B/C/D/example.ts"
 8 | 	 * @param filename 传入的文件路径
 9 | 	 */
10 | 	normalize: (filename: string) => {
11 | 		// 检查是否包含协议 (https://, file://, wxfile:// 等)
12 | 		const protocolMatch = filename.match(/^([a-z]+:\/\/)/);
13 | 		let protocol = '';
14 | 
15 | 		if (protocolMatch) {
16 | 			// 提取协议部分，如 "http://"
17 | 			protocol = protocolMatch[1];
18 | 			// 去除协议部分，处理剩下的路径
19 | 			filename = filename.replace(protocol, '');
20 | 		}
21 | 
22 | 		// 将所有反斜杠替换为正斜杠
23 | 		filename = filename.replace(/\\/g, '/');
24 | 
25 | 		// 删除多余的斜杠
26 | 		filename = filename.replace(/\/+/g, '/');
27 | 
28 | 		// 如果有协议，则将协议加回去
29 | 		return protocol + filename;
30 | 	},
31 | 
32 | 	/**
33 | 	 * 根据文件路径得到文件名字，"C:/A/B/example.ts"=>"example.ts"
34 | 	 * @param filename 传入的文件路径
35 | 	 * @return 文件的名字
36 | 	 */
37 | 	basename: (filename: string): string => {
38 | 		filename = path.normalize(filename);
39 | 		return filename.substring(filename.lastIndexOf('/') + 1);
40 | 	},
41 | 
42 | 	/**
43 | 	 * 文件所在文件夹路径，"C:/A/B/example.ts"=>"C:/A/B"
44 | 	 * @param path 传入的文件路径
45 | 	 * @return 文件所在文件夹的地址
46 | 	 */
47 | 	dirname: (filename: string): string => {
48 | 		filename = path.normalize(filename);
49 | 		// 检查路径是否包含协议前缀 (例如 'tinyfs://')
50 | 		const protocolIndex = filename.indexOf('://');
51 | 		let prefix = '';
52 | 		if (protocolIndex !== -1) {
53 | 			prefix = filename.substring(0, protocolIndex + 3);
54 | 			filename = filename.substring(protocolIndex + 3);
55 | 		}
56 | 		const dir = filename.substring(0, filename.lastIndexOf('/'));
57 | 		return prefix + dir;
58 | 	},
59 | 
60 | 	/**
61 | 	 * 获得文件拓展名 " text.txt" => "txt"
62 | 	 * @param path 传入的文件路径
63 | 	 */
64 | 	extension: (filename: string): string => {
65 | 		const pos = filename.lastIndexOf('.');
66 | 		if (pos >= 0 && pos < filename.length - 1) {
67 | 			return filename.substring(pos + 1, filename.length);
68 | 		}
69 | 		return '';
70 | 	},
71 | 
72 | 	/**
73 | 	 * 获得文件拓展名 " text.yaml.txt" => "yaml.txt"
74 | 	 * @param path 传入的文件路径
75 | 	 */
76 | 	fullExtension: (filename: string): string => {
77 | 		filename = path.basename(filename);
78 | 		const pos = filename.indexOf('.');
79 | 		if (pos >= 0 && pos < filename.length - 1) {
80 | 			return filename.substring(pos + 1, filename.length);
81 | 		}
82 | 		return '';
83 | 	},
84 | 
85 | 	join(dir: string, ...pathes: string[]) {
86 | 		let ret = dir;
87 | 		for (const p of pathes) {
88 | 			if (p) {
89 | 				ret += '/' + p;
90 | 			}
91 | 		}
92 | 		return ret;
93 | 	}
94 | };
95 | 


--------------------------------------------------------------------------------
/src/framework/platform/utils/SubPackageLoader.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from 'framework/tiny/core/EventEmitter';
 2 | import { AsyncOperation } from 'framework/tiny/core/async-operation/AsyncOperation';
 3 | 
 4 | type PackageLoaderTaskEvents = {
 5 | 	done: () => void,
 6 | 	faild: (err: Error) => void;
 7 | 	progress: (current: number, total: number) => void;
 8 | };
 9 | export class SubPackageLoadTask extends EventEmitter<PackageLoaderTaskEvents>{
10 | 	constructor(readonly subpackage: ISubPackage) {
11 | 		super();
12 | 	}
13 | }
14 | 
15 | /** 小游戏分包加载器 */
16 | export class SubPackageLoader extends AsyncOperation<void> {
17 | 	verbose?: boolean;
18 | 
19 | 	static readonly LOADED_SUBPACKAGES = new Set((config.subpackages || []).filter(p => p.priority === 'bootstrap'));
20 | 	static readonly LOADING_SUBPACKAGES = new Map<ISubPackage, SubPackageLoadTask>();
21 | 
22 | 	constructor(readonly pkg: ISubPackage) {
23 | 		super({ description: `load subpackage ${pkg.name}` });
24 | 	}
25 | 
26 | 	start() {
27 | 		super.start();
28 | 		this.$progress.total = 1;
29 | 		this.$progress.current = 0;
30 | 		const loader = config.subpackage_loader;
31 | 		if (loader) {
32 | 			if (SubPackageLoader.LOADED_SUBPACKAGES.has(this.pkg)) {
33 | 				this.done();
34 | 			} else if (SubPackageLoader.LOADING_SUBPACKAGES.has(this.pkg)) {
35 | 				const task = SubPackageLoader.LOADING_SUBPACKAGES.get(this.pkg);
36 | 				const onDone = () => {
37 | 					this.done();
38 | 					clear();
39 | 				};
40 | 				const onError = (err: Error) => {
41 | 					this.fail(err);
42 | 					clear();
43 | 				};
44 | 				const onProgress = (c: number, t: number) => this.updateProgress(c / t);
45 | 				const clear = () => {
46 | 					task.off('done', onDone);
47 | 					task.off('faild', onError);
48 | 					task.off('progress', onProgress);
49 | 				};
50 | 				task.once('done', onDone);
51 | 				task.once('faild', onError);
52 | 				task.on('progress', onProgress);
53 | 			} else {
54 | 				if (this.verbose) console.log('开始加载分包', this.pkg.name);
55 | 				const task = new SubPackageLoadTask(this.pkg);
56 | 				SubPackageLoader.LOADING_SUBPACKAGES.set(this.pkg, task);
57 | 				const rawTask = loader({
58 | 					name: this.pkg.name,
59 | 					success: () => {
60 | 						SubPackageLoader.LOADED_SUBPACKAGES.add(this.pkg);
61 | 						SubPackageLoader.LOADING_SUBPACKAGES.delete(this.pkg);
62 | 						if (this.verbose) console.log('已加载分包', this.pkg.name);
63 | 						this.updateProgress(this.$progress.total);
64 | 						this.done();
65 | 						task.emit('done');
66 | 					},
67 | 					fail: (err: string) => {
68 | 						SubPackageLoader.LOADING_SUBPACKAGES.delete(this.pkg);
69 | 						const error = new Error(`分包加载失败: ${this.pkg} ${err}`);
70 | 						this.fail(error);
71 | 						task.emit('faild', error);
72 | 					}
73 | 				});
74 | 				if (rawTask && rawTask.onProgressUpdate) {
75 | 					rawTask.onProgressUpdate(res => {
76 | 						this.updateProgress(res.totalBytesWritten / res.totalBytesExpectedToWrite);
77 | 						task.emit('progress', res.totalBytesWritten, res.totalBytesExpectedToWrite);
78 | 					});
79 | 				}
80 | 			}
81 | 		}
82 | 	}
83 | 
84 | 	protected updateProgress(value: number) {
85 | 		this.$progress.current = value;
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/canvas.ts:
--------------------------------------------------------------------------------
  1 | import { dataUriToBuffer } from 'data-uri-to-buffer';
  2 | import { TinyObject } from 'framework/tiny/core/TinyObject';
  3 | 
  4 | export const DefaultWebFont: Record<OSType, string> = {
  5 | 	'ios': 'PingFangSC-Regular',
  6 | 	'android': 'Noto Sans CJK SC',
  7 | 	'windows': 'Microsoft YaHei',
  8 | 	'macos': 'PingFangSC-Regular',
  9 | 	'linux': 'Microsoft YaHei',
 10 | 	'unknown': 'Arial',
 11 | 	'devtools': 'Microsoft YaHei',
 12 | };
 13 | 
 14 | export class WebCanvas extends TinyObject {
 15 | 
 16 | 	protected $canvas: HTMLCanvasElement;
 17 | 	get canvas() {
 18 | 		if (!this.$canvas) {
 19 | 			this.$canvas = this.createCanvas();
 20 | 		}
 21 | 		return this.$canvas;
 22 | 	}
 23 | 
 24 | 	dispose() {
 25 | 		this.$canvas = null;
 26 | 	}
 27 | 
 28 | 	constructor(readonly options: { defaultFont?: string; } = {}) {
 29 | 		super();
 30 | 	}
 31 | 
 32 | 	createCanvas() {
 33 | 		return document.createElement('canvas');
 34 | 	}
 35 | 
 36 | 	createImage() {
 37 | 		return new Image();
 38 | 	}
 39 | 
 40 | 	/**
 41 | 	 * 渲染文字到贴图，不支持换行
 42 | 	 * 该函数主要用于渲染用户名称等不易使用游戏字体进行渲染的文字内容
 43 | 	 */
 44 | 	renderText(text: string, style: Partial<TextStyle>): Promise<ArrayBuffer> {
 45 | 		return new Promise((resolve, reject) => {
 46 | 			try {
 47 | 				const canvas = this.canvas;
 48 | 				const ctx = canvas.getContext('2d');
 49 | 				const fontSize = style.fontSize || 16;
 50 | 				const font = `${style.bold ? 'bold ' : ''}${style.italic ? 'italic ' : ''}${fontSize}px '${style.font || this.options.defaultFont || 'Arial'}'`;
 51 | 				ctx.font = font;
 52 | 				const m = ctx.measureText(text);
 53 | 				const width = Math.ceil(m.width) + 4;
 54 | 				let height = Math.ceil(m.fontBoundingBoxAscent + (m.actualBoundingBoxDescent || m.fontBoundingBoxDescent));
 55 | 				if (!height) height = style.fontSize * 1.2;
 56 | 				canvas.width = width;
 57 | 				canvas.height = height;
 58 | 				ctx.clearRect(0, 0, width, height);
 59 | 
 60 | 				ctx.font = font;
 61 | 				ctx.fillStyle = style.color || 'white';
 62 | 
 63 | 				if (style.strokeWidth) {
 64 | 					ctx.strokeStyle = style.strokeColor || 'black';
 65 | 					ctx.lineWidth = style.strokeWidth;
 66 | 				}
 67 | 				ctx.fillText(text, 0, m.actualBoundingBoxAscent || m.fontBoundingBoxAscent);
 68 | 				if (style.strokeWidth) {
 69 | 					ctx.strokeText(text, 0, m.actualBoundingBoxAscent || m.fontBoundingBoxAscent);
 70 | 				}
 71 | 				const dataURL = canvas.toDataURL('image/png');
 72 | 				const ret = dataUriToBuffer(dataURL);
 73 | 				resolve(ret.buffer);
 74 | 			} catch (error) {
 75 | 				reject(error);
 76 | 			}
 77 | 		});
 78 | 	}
 79 | 
 80 | 	/** 加载图像内容 */
 81 | 	loadImageBuffer(url: string): Promise<ArrayBuffer> {
 82 | 		return new Promise((resolve, reject) => {
 83 | 			const img = this.createImage();
 84 | 			const clear = () => {
 85 | 				img.src = '';
 86 | 				img.onload = null;
 87 | 				img.onerror = null;
 88 | 			};
 89 | 			img.onload = () => {
 90 | 				const canvas = this.canvas;
 91 | 				canvas.width = img.width;
 92 | 				canvas.height = img.height;
 93 | 				const ctx = canvas.getContext('2d');
 94 | 				ctx.clearRect(0, 0, canvas.width, canvas.height);
 95 | 				ctx.drawImage(img, 0, 0);
 96 | 				clear();
 97 | 				const dataURL = canvas.toDataURL('image/png');
 98 | 				const ret = dataUriToBuffer(dataURL);
 99 | 				resolve(ret.buffer);
100 | 			};
101 | 			img.onerror = (evt) => {
102 | 				clear();
103 | 				reject(new Error('Failed to load image at ' + url));
104 | 			};
105 | 			img.crossOrigin = 'anonymous';
106 | 			img.src = url;
107 | 		});
108 | 	}
109 | }
110 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/recorder.bytedance.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | import { EventEmitter } from 'framework/tiny/core/EventEmitter';
  3 | import { PureBasicStateMachine } from 'framework/tiny/utils/StateMachine.basic';
  4 | 
  5 | export interface BytedanceShareParams {
  6 | 	/** 分享模板 ID */
  7 | 	templateId?: string;
  8 | 	/** 标题 */
  9 | 	title: string;
 10 | 	/** 文字内容 */
 11 | 	desc?: string;
 12 | 	/** 图片地址 */
 13 | 	imageUrl?: string;
 14 | 	/** 视频话题(仅抖音支持) ，目前由 hashtag_list 代替，为保证兼容性，建议同时填写两个。 */
 15 | 	videoTopics?: string[];
 16 | 	/** 生成输入的默认文案 */
 17 | 	video_title?: string;
 18 | 	/** 视频话题(仅抖音支持) */
 19 | 	hashtag_list?: string[];
 20 | 	/** 抖音 pgc 音乐的短链(仅抖音支持，需要基础库版本大于 1.90) 。形如 https://v.douyin.com/JmcxWo8/， 参考 抖音小游戏录屏带配乐能力 */
 21 | 	defaultBgm?: string;
 22 | 	/** 分享视频的标签，可以结合获取抖音视频排行榜使用 */
 23 | 	videoTag?: string;
 24 | }
 25 | 
 26 | export class BytedanceGameRecorder extends PureBasicStateMachine<RecorderState> implements IGameRecorder {
 27 | 	readonly event: EventEmitter<IRecorderEventMap>;
 28 | 	readonly lastRecordVideoPath: string;
 29 | 	readonly lastRecordVideoId: number;
 30 | 	public get recordSharedCount(): number { return this.$recordSharedCount; }
 31 | 	protected $recordSharedCount: number;
 32 | 
 33 | 	constructor(readonly native: tt.GameRecorderManager) {
 34 | 		super('idle');
 35 | 		this.native.onStart(() => {
 36 | 			this.state = 'recording';
 37 | 			this.event.emit('start');
 38 | 		});
 39 | 		this.native.onStop(res => {
 40 | 			this.state = 'stop';
 41 | 			this.event.emit('stop', res.videoPath);
 42 | 			(this.lastRecordVideoPath as string) = res.videoPath;
 43 | 		});
 44 | 		this.native.onPause(() => {
 45 | 			this.state = 'pause';
 46 | 			this.event.emit('pause');
 47 | 		});
 48 | 		this.native.onResume(() => {
 49 | 			this.state = 'recording';
 50 | 			this.event.emit('resume');
 51 | 		});
 52 | 		this.native.onError(err => {
 53 | 			this.state = 'idle';
 54 | 			this.event.emit('error', err.errMsg);
 55 | 		});
 56 | 		this.native.onInterruptionBegin(() => this.event.emit('interruption-begin'));
 57 | 		this.native.onInterruptionEnd(() => this.event.emit('interruption-end'));
 58 | 	}
 59 | 
 60 | 	/**
 61 | 	 * 开始录屏
 62 | 	 * @param duration 录屏时长（秒）
 63 | 	 * @param frameRate 帧率，默认30
 64 | 	 */
 65 | 	start(duration: number, frameRate: number = 30) {
 66 | 		this.native.start({ duration, frameRate });
 67 | 	}
 68 | 
 69 | 	/** 停止录屏 */
 70 | 	stop() {
 71 | 		this.native.stop();
 72 | 	}
 73 | 
 74 | 	/** 暂停 */
 75 | 	pause() {
 76 | 		this.native.pause();
 77 | 	}
 78 | 
 79 | 	/** 继续录屏 */
 80 | 	resume() {
 81 | 		this.native.resume();
 82 | 	}
 83 | 
 84 | 	/** 分享录屏 */
 85 | 	share(params: BytedanceShareParams = { title: '测试' }): Promise<{ videoId: string; }> {
 86 | 		return new Promise((resolve, reject) => {
 87 | 			if (!this.lastRecordVideoPath) reject();
 88 | 			const extra = {
 89 | 				withVideoId: true,
 90 | 				videoPath: this.lastRecordVideoPath
 91 | 			};
 92 | 			for (const key of ['videoTopics', 'video_title', 'hashtag_list', 'defaultBgm', 'videoTag']) {
 93 | 				// @ts-expect-error
 94 | 				if (params[key]) extra[key] = params[key];
 95 | 			}
 96 | 			tt.shareAppMessage({
 97 | 				title: params.title,
 98 | 				desc: params.desc,
 99 | 				imageUrl: params.imageUrl,
100 | 				templateId: params.templateId,
101 | 				channel: 'video',
102 | 				extra,
103 | 				success: (ret: any) => {
104 | 					this.$recordSharedCount += 1;
105 | 					resolve(ret);
106 | 				},
107 | 				fail: () => {
108 | 					reject(new Error('分享录屏失败'));
109 | 				}
110 | 			});
111 | 		});
112 | 	}
113 | 
114 | }
115 | 


--------------------------------------------------------------------------------
/src/framework/platform/platform.common.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter } from 'framework/tiny/core/EventEmitter';
 2 | import { globalGet } from 'framework/tiny/core/global';
 3 | 
 4 | class InpackageReadonlyFileSystem implements IReadonlyFilesSystem {
 5 | 	constructor(readonly fs: IReadonlyFilesSystem, readonly platform: Platform) {}
 6 | 
 7 | 	exists(filePath: string) { return this.fs.exists(filePath); }
 8 | 	existsSync(filePath: string) { return this.fs.existsSync(filePath); }
 9 | 	stat(filePath: string) { return this.fs.stat(filePath); }
10 | 	statSync(filePath: string): Stat { return this.fs.statSync(filePath); }
11 | 	readdir(dirPath: string) { return this.fs.readdir(dirPath); }
12 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
13 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
14 | 	async readFile(filePath: unknown, encoding: unknown): Promise<string | ArrayBuffer> {
15 | 		if (this.platform.check('readLocalFile')) {
16 | 			try {
17 | 				return this.platform.readLocalFile(filePath as string, encoding === 'utf8' || encoding === 'utf-8' ? 'text' : 'binary');
18 | 			} catch (error) {
19 | 				// pass
20 | 			}
21 | 		}
22 | 		return this.fs.readFile(filePath as string, encoding as 'binary');
23 | 	}
24 | }
25 | 
26 | export class GamePlatformBase extends EventEmitter<ApplicationEvents> implements Platform {
27 | 
28 | 	get persistentDataPath() { return ''; }
29 | 	get channel(): string { return this.type; }
30 | 	get type(): string { return 'laya-base'; }
31 | 	get isRunningInBrowser() { return typeof window === 'object' && typeof document === 'object' && typeof window.navigator === 'object' && typeof window.history === 'object' && typeof window.location === 'object'; }
32 | 	get os(): OSInformation { return null; }
33 | 	get device(): DeviceInformation { return null; }
34 | 	get application(): HostApplicationInformation { return null; }
35 | 	get launchOptions(): { path?: string; query?: object; scene?: string | number; group_id?: string; } { return null; }
36 | 	readonly localStorage: LocalStorage;
37 | 
38 | 	protected $launchAt = globalGet('launchAt') || Date.now();
39 | 	now(): number {
40 | 		if (typeof performance !== 'undefined') {
41 | 			return performance.now();
42 | 		}
43 | 		return (Date.now() - this.$launchAt);
44 | 	}
45 | 
46 | 	protected setState(v: keyof ApplicationEvents) {
47 | 		if (v != this.$state) {
48 | 			this.$state = v;
49 | 			this.emit(v);
50 | 		}
51 | 	}
52 | 	private $state: keyof ApplicationEvents;
53 | 
54 | 	get http(): http { return this.$http; }
55 | 	protected $http: http;
56 | 
57 | 	check(type: keyof Platform): boolean {
58 | 		// @ts-expect-error check if the property exists
59 | 		return typeof this[type] !== 'undefined';
60 | 	}
61 | 
62 | 	protected wrapReadonlyFS(fs: IReadonlyFilesSystem): InpackageReadonlyFileSystem {
63 | 		return new InpackageReadonlyFileSystem(fs, this);
64 | 	}
65 | 
66 | 	alert(message: string, title?: string): Promise<void> {
67 | 		return Promise.reject(new Error('Method not implemented.'));
68 | 	}
69 | 
70 | 	accept(message: string, title?: string, confirm?: string, cancel?: string): Promise<void> {
71 | 		return Promise.reject(new Error('Method not implemented.'));
72 | 	}
73 | 
74 | 	toast(message: string, icon?: ToastType): Promise<void> {
75 | 		return Promise.reject(new Error('Method not implemented.'));
76 | 	}
77 | 
78 | 	vibrate(durationMs: number): void {
79 | 		throw new Error('Method not implemented.');
80 | 	}
81 | 
82 | 	reload(): Promise<void> {
83 | 		return Promise.reject(new Error('Method not implemented.'));
84 | 	}
85 | 
86 | 	exit(): Promise<void> {
87 | 		return Promise.reject(new Error('Method not implemented.'));
88 | 	}
89 | }
90 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/http.xhr.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | import querystring from 'qs';
  3 | type XMLHttpRequestMethod = 'GET' | 'POST' | 'DELETE' | 'PUT';
  4 | 
  5 | export class XHRHttp implements http {
  6 | 
  7 | 	timeout: number = 5;
  8 | 	headers: Record<string, string>;
  9 | 
 10 | 	private async getResponseData(request: XMLHttpRequest): Promise<BodyInit> {
 11 | 		let data: BodyInit;
 12 | 		const contentType = request.getResponseHeader('content-type') || request.getResponseHeader('Content-Type') || '';
 13 | 		if (contentType.indexOf('application/json') !== -1) {
 14 | 			if (typeof request.response === 'string') {
 15 | 				data = JSON.parse(request.response);
 16 | 			} else {
 17 | 				data = request.response;
 18 | 			}
 19 | 		} else if (contentType.indexOf('application/x-www-form-urlencoded') !== -1) {
 20 | 			if (typeof request.response === 'string') {
 21 | 				data = querystring.parse(request.response) as unknown as BodyInit;
 22 | 			} else {
 23 | 				data = request.response;
 24 | 			}
 25 | 		} else if (contentType.indexOf('text/plain') !== -1) {
 26 | 			data = request.responseText || request.response;
 27 | 		} else if (contentType.indexOf('application/octet-stream') !== -1) {
 28 | 			data = request.response;
 29 | 		}
 30 | 		if (data === undefined) data = request.response as BodyInit;
 31 | 		if (typeof data === 'string' && ((data.startsWith('{') && data.endsWith('}')) || (data.startsWith('[') && data.endsWith(']')))) {
 32 | 			try { data = JSON.parse(data); } catch (error) { /* empty */ }
 33 | 		}
 34 | 		return data;
 35 | 	}
 36 | 
 37 | 	fetch(method: XMLHttpRequestMethod, url: string, body?: BodyInit | Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any> {
 38 | 		return new Promise((done, fail) => {
 39 | 			let handled = false;
 40 | 			const resolve = (ret: any) => {
 41 | 				if (!handled) {
 42 | 					handled = true;
 43 | 					done(ret);
 44 | 				}
 45 | 			};
 46 | 			const reject = (err: any) => {
 47 | 				if (!handled) {
 48 | 					handled = true;
 49 | 					fail(err);
 50 | 				}
 51 | 			};
 52 | 			const request = new XMLHttpRequest();
 53 | 			request.timeout = this.timeout * 1000;
 54 | 			request.onload = async () => {
 55 | 				if (request.status >= 400) {
 56 | 					reject({ data: request.response, method, url, code: request.status, message: `Response error` });
 57 | 					return;
 58 | 				}
 59 | 				resolve(await this.getResponseData(request));
 60 | 			};
 61 | 			request.onerror = async (evt) => {
 62 | 				const data = await this.getResponseData(request) || undefined;
 63 | 				reject({ data, method, code: request.status || 0, url, message: `Reqest failed` });
 64 | 			};
 65 | 			request.onabort = () => { reject({ url, method, code: -1, message: `Request abort` }); };
 66 | 			request.ontimeout = () => { reject({ url, method, code: -2, message: `Request timeout` }); };
 67 | 			request.open(method, url);
 68 | 			if (responseType) request.responseType = 'arraybuffer';
 69 | 			headers = headers || this.headers;
 70 | 			if (typeof headers === 'object') {
 71 | 				for (const key of Object.getOwnPropertyNames(headers)) {
 72 | 					request.setRequestHeader(key, headers[key]);
 73 | 				}
 74 | 			}
 75 | 
 76 | 			const contentType = request.getResponseHeader('Content-Type') || request.getResponseHeader('content-type');
 77 | 			if (!contentType) {
 78 | 				if (typeof body === 'object') {
 79 | 					if (!(body instanceof ArrayBuffer)) {
 80 | 						request.setRequestHeader('Content-Type', 'application/json;charset=UTF-8');
 81 | 						body = JSON.stringify(body);
 82 | 					}
 83 | 				} else if (typeof body === 'string') {
 84 | 					request.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
 85 | 				}
 86 | 			}
 87 | 			request.send(body as string | ArrayBuffer);
 88 | 		});
 89 | 	}
 90 | 
 91 | 	post(url: string, data?: BodyInit | Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any> {
 92 | 		return this.fetch('POST', url, data, headers, responseType);
 93 | 	}
 94 | 
 95 | 	get(url: string, params?: Record<string, any>, headers?: Record<string, string>, responseType?: string): Promise<any> {
 96 | 		const qs = querystring.stringify(params as any);
 97 | 		if (qs) {
 98 | 			url += `?${qs}`;
 99 | 		}
100 | 		return this.fetch('GET', url, undefined, headers, responseType);
101 | 	}
102 | }
103 | 


--------------------------------------------------------------------------------
/src/framework/tiny/core/EventEmitter.ts:
--------------------------------------------------------------------------------
  1 | import { HashObject } from './HashObject';
  2 | interface EventHandler {
  3 | 	(...args: any[]): void;
  4 | }
  5 | interface EventMap {
  6 | 	[key: string]: EventHandler;
  7 | }
  8 | 
  9 | interface HandlerOptions {
 10 | 	/** 只执行一次 */
 11 | 	once?: boolean;
 12 | 	/** 阻止后面的回调被派发 */
 13 | 	block?: boolean;
 14 | }
 15 | interface InternalEnternalHandler {
 16 | 	handler: EventHandler;
 17 | 	options?: HandlerOptions;
 18 | }
 19 | type InternalEventHandlerList = InternalEnternalHandler[];
 20 | 
 21 | /**
 22 |  * 事件派发器，事件派发机制的实现
 23 |  *
 24 |  * @export
 25 |  * @class EventEmitter
 26 |  * @extends {HashObject}
 27 |  */
 28 | export class EventEmitter<T extends EventMap = EventMap> extends HashObject {
 29 | 
 30 | 	constructor() { super(); }
 31 | 	private readonly $all = new Map<string, InternalEnternalHandler[]>();
 32 | 
 33 | 	/**
 34 | 	 * 添加事件监听器
 35 | 	 *
 36 | 	 * @param {EventType} type 事件类型
 37 | 	 * @param {EventHandler} handler 事件回调
 38 | 	 * @param {boolean} [options] 派发一次事件后移除该事件
 39 | 	 * @returns 返回绑定的回调函数，可用于取消绑定
 40 | 	 * @memberof EventEmitter
 41 | 	 */
 42 | 	on<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void, options?: HandlerOptions) {
 43 | 		const handlers = this.$all.get(type as string);
 44 | 		const h = { handler, options };
 45 | 		const added = handlers && handlers.push(h);
 46 | 		if (!added) {
 47 | 			this.$all.set(type as string, [h]);
 48 | 		}
 49 | 		return h.handler;
 50 | 	}
 51 | 
 52 | 	/**
 53 | 	 * 添加事件监听器, 事件派发后自动解绑
 54 | 	 *
 55 | 	 * @param {EventType} type 事件类型
 56 | 	 * @param {EventHandler} handler 事件回调
 57 | 	 * @param {boolean} [options] 派发一次事件后移除该事件
 58 | 	 * @returns 返回绑定的回调函数，可用于取消绑定
 59 | 	 * @returns EventEmitter
 60 | 	 */
 61 | 	once<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void, options?: HandlerOptions) {
 62 | 		const opt = options || {};
 63 | 		opt.once = true;
 64 | 		return this.on(type, handler, opt);
 65 | 	}
 66 | 
 67 | 	/**
 68 | 	 * 转发事件
 69 | 	 * @param target 目标代理对象
 70 | 	 * @param type 时间类型
 71 | 	 * @param options 配置参数
 72 | 	 * @returns 返回代理回调，可用于取消转发
 73 | 	 */
 74 | 	pipe<T2 extends EventMap>(target: EventEmitter<T2>, type: keyof (T | T2), options?: HandlerOptions) {
 75 | 		type K = keyof (T | T2);
 76 | 		// @ts-ignore
 77 | 		if (target == this) return undefined;
 78 | 		const callback = function() {
 79 | 			// eslint-disable-next-line prefer-rest-params
 80 | 			target.emit.apply(target, [type as K, ...arguments]);
 81 | 		};
 82 | 		this.on(type as K, callback, options);
 83 | 		return callback;
 84 | 	}
 85 | 
 86 | 	/**
 87 | 	 * 移除事件监听器
 88 | 	 *
 89 | 	 * @param {EventType} type 事件类型
 90 | 	 * @param {EventHandler} handler 要移除的回调
 91 | 	 * @memberof EventEmitter
 92 | 	 */
 93 | 	off<K extends keyof T>(type: K, handler: (...args: Parameters<T[K]>) => void) {
 94 | 		const handlers = this.$all.get(type as string);
 95 | 		if (handlers) {
 96 | 			const h = handlers.find(h => h.handler === handler);
 97 | 			if (h) {
 98 | 				handlers.splice(handlers.indexOf(h), 1);
 99 | 			}
100 | 		}
101 | 	}
102 | 
103 | 	/**
104 | 	 * 移除特定类型是所有事件监听器
105 | 	 *
106 | 	 * @param {EventType} type 事件类型，传入`*`则清理所有类型的事件回调
107 | 	 * @memberof EventEmitter
108 | 	 */
109 | 	offAll<K extends keyof T>(type: K | '*') {
110 | 		if (type === '*') {
111 | 			this.$all.clear();
112 | 		} else {
113 | 			this.$all.delete(type as string);
114 | 		}
115 | 	}
116 | 
117 | 	/**
118 | 	 * 派发事件
119 | 	 *
120 | 	 * @param {EventType} type 事件类型
121 | 	 * @param {...any[]} args 派发参数表
122 | 	 * @memberof EventEmitter
123 | 	 */
124 | 	emit<K extends keyof T>(type: K, ...args: Parameters<T[K]>) {
125 | 		const handlers: InternalEventHandlerList = [];
126 | 		let blocking = false;
127 | 		for (const h of ((this.$all.get(type as string) || []) as InternalEventHandlerList).slice()) {
128 | 			const currentBlocking = h.options && h.options.block;
129 | 			const currentOnce = h.options && h.options.once;
130 | 			if (!blocking) h.handler(...args);
131 | 			if (!currentOnce || blocking) handlers.push(h);
132 | 			blocking = blocking || currentBlocking;
133 | 		}
134 | 		this.$all.set(type as string, handlers);
135 | 	}
136 | 
137 | 	/** 等待事件派发 */
138 | 	wait<K extends keyof T>(event: K): Promise<unknown[]> {
139 | 		return new Promise((resolve, reject) => {
140 | 			this.on(event, (...args: any[]) => { resolve(args); }, { once: true });
141 | 		});
142 | 	}
143 | 
144 | 	/** 销毁时解绑所有事件 */
145 | 	dispose() {
146 | 		this.$all.clear();
147 | 	}
148 | }
149 | 


--------------------------------------------------------------------------------
/src/framework/tiny/core/async-operation/AsyncOperation.ts:
--------------------------------------------------------------------------------
  1 | import { EventEmitter } from '../EventEmitter';
  2 | import { TinyObject } from '../TinyObject';
  3 | 
  4 | 
  5 | export interface IAsyncOperationProgress {
  6 | 	/** 能否计算 */
  7 | 	computable?: boolean;
  8 | 	/** 当前值 */
  9 | 	current: number;
 10 | 	/** 总值 */
 11 | 	total: number;
 12 | }
 13 | 
 14 | export const NON_COMPUTABLE_PROGRESS: Readonly<IAsyncOperationProgress> = { computable: false, current: 0, total: 1 };
 15 | export const EMPTY_PROGRESS: Readonly<IAsyncOperationProgress> = { computable: true, current: 0, total: 1 };
 16 | export const FULL_PROGRESS: Readonly<IAsyncOperationProgress> = { computable: true, current: 1, total: 1 };
 17 | 
 18 | export class CancelError extends Error {
 19 | 	constructor(message?: string) {
 20 | 		super(message);
 21 | 		this.name = 'Canceled';
 22 | 	}
 23 | }
 24 | 
 25 | export type AsyncOperationState = 'pending' | 'processing' | 'done' | 'failed' | 'canceled';
 26 | export interface IAsyncOperationInit {
 27 | 	weight?: number;
 28 | 	description?: string;
 29 | }
 30 | 
 31 | export class AsyncOperation<T = unknown> extends TinyObject {
 32 | 
 33 | 	readonly event: EventEmitter<{
 34 | 		/** 开始操作 */
 35 | 		start(): void;
 36 | 		/** 被取消 */
 37 | 		canceled(): void;
 38 | 		/** 任务完成 */
 39 | 		done(result?: T): void;
 40 | 		/** 任务失败 */
 41 | 		failed(error?: Error): void;
 42 | 		/** 任务完成或失败 */
 43 | 		complete(result?: T, error?: Error): void;
 44 | 		/** 状态改变事件 */
 45 | 		stateChanged(state: AsyncOperationState): void;
 46 | 	}>;
 47 | 
 48 | 	/** 权重 */
 49 | 	public weight: number = 1;
 50 | 	/** 描述信息 */
 51 | 	readonly description?: string;
 52 | 	/** 失败的错误信息 */
 53 | 	readonly error?: Error;
 54 | 	/** 执行成功结果 */
 55 | 	readonly result?: T;
 56 | 
 57 | 	/** 是否已经执行结束 */
 58 | 	get settled(): boolean { return this.$state != 'pending' && this.$state != 'processing'; }
 59 | 	get started(): boolean { return this.$state == 'processing'; }
 60 | 	/** 任务进度 */
 61 | 	get progress(): Readonly<IAsyncOperationProgress> { return this.$progress; }
 62 | 	/** 进度百分比 */
 63 | 	get percent(): number {
 64 | 		const { current, total } = this.progress;
 65 | 		return current / Math.max(total || 1, current);
 66 | 	}
 67 | 
 68 | 	protected $progress: IAsyncOperationProgress = Object.assign({}, NON_COMPUTABLE_PROGRESS);
 69 | 	/** 获取 Promise 对象 */
 70 | 	get promise(): Promise<T> {
 71 | 		if (!this.$promise) {
 72 | 			if (this.settled) {
 73 | 				this.$promise = this.$state === 'done' ? Promise.resolve(this.result) : Promise.reject(this.error);
 74 | 			} else {
 75 | 				this.$promise = new Promise<T>((resolve, reject) => {
 76 | 					this.event.once('done', resolve);
 77 | 					this.event.once('failed', reject);
 78 | 					this.event.once('canceled', () => reject(this.error));
 79 | 				});
 80 | 			}
 81 | 		}
 82 | 		return this.$promise;
 83 | 	}
 84 | 	protected $promise: Promise<T>;
 85 | 
 86 | 	/** 设置状态 */
 87 | 	settle(v: 'done' | 'failed' | 'canceled', result?: T, reason?: Error) {
 88 | 		if (v != this.$state) {
 89 | 			this.$state = v;
 90 | 			if (v === 'done') {
 91 | 				(this.result as T) = result;
 92 | 				this.event.emit(v, result);
 93 | 			} if (reason) {
 94 | 				(this.error as Error) = reason;
 95 | 				this.event.emit(v, reason);
 96 | 			}
 97 | 			this.event.emit('stateChanged', this.$state);
 98 | 			this.event.emit('complete', result, reason);
 99 | 		}
100 | 	}
101 | 
102 | 	get state(): AsyncOperationState { return this.$state; }
103 | 	private $state: AsyncOperationState = 'pending';
104 | 
105 | 	constructor(init?: IAsyncOperationInit) {
106 | 		super();
107 | 		if (init) {
108 | 			this.weight = typeof (init.weight) == 'number' ? Math.max(init.weight, 1) : 1;
109 | 			this.description = init.description;
110 | 		}
111 | 	}
112 | 
113 | 	start() {
114 | 		if (this.$state == 'pending') {
115 | 			this.$state = 'processing';
116 | 			this.event.emit('stateChanged', this.$state);
117 | 			this.event.emit('start');
118 | 			return;
119 | 		}
120 | 	}
121 | 
122 | 	/** 是否允许执行取消操作 */
123 | 	get cancelable() { return !this.settled; }
124 | 	/** 执行取消操作 */
125 | 	cancel() {
126 | 		if (this.cancelable) {
127 | 			this.settle('canceled', undefined, new CancelError('Operation canceled'));
128 | 		} else {
129 | 			throw new Error('Operation not cancelable');
130 | 		}
131 | 	}
132 | 
133 | 	protected done(value: T) {
134 | 		this.$progress.current = this.$progress.total;
135 | 		this.settle('done', value);
136 | 	}
137 | 
138 | 	protected fail(reason?: Error) {
139 | 		this.settle('failed', undefined, reason);
140 | 	}
141 | }
142 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/index.ts:
--------------------------------------------------------------------------------
  1 | export type Nullable<T> = T | null | undefined;
  2 | 
  3 | /**
  4 |  * 在数组中随机抽取一个元素
  5 |  * @param list 要抽取的数组
  6 |  */
  7 | export function randomOne<T>(list: readonly T[]): Nullable<T> {
  8 | 	if (!Array.isArray(list) || !list.length) return undefined;
  9 | 	const idx = Math.floor(list.length * Math.random());
 10 | 	return list[idx];
 11 | }
 12 | 
 13 | /**
 14 |  * 合并两个集合,不会出现重复元素，返回无序的并集
 15 |  *
 16 |  * @export
 17 |  * @template T
 18 |  * @param {IterableIterator<T>} a 集合A
 19 |  * @param {IterableIterator<T>} b 集合B
 20 |  * @returns {IterableIterator<T>} 并集
 21 |  */
 22 | export function merge<T>(a: IterableIterator<T>, b: IterableIterator<T>): IterableIterator<T> {
 23 | 	const set = new Set<T>(a);
 24 | 	for (const bi of b) {
 25 | 		set.add(bi);
 26 | 	}
 27 | 
 28 | 	return set.values();
 29 | }
 30 | 
 31 | /**
 32 |  * 从数组中移除元素
 33 |  *
 34 |  * @export
 35 |  * @template T 数组类型
 36 |  * @param {T[]} array 数组对象
 37 |  * @param {T} element 要移除的元素
 38 |  * @returns 返回移除元素后的原数组对象
 39 |  */
 40 | export function arrayErase<T>(array: T[], element: T) {
 41 | 	const index = array.indexOf(element, 0);
 42 | 	if (index > -1) {
 43 | 		array.splice(index, 1);
 44 | 	}
 45 | 	return array;
 46 | }
 47 | 
 48 | /** 随机打乱数组 */
 49 | export function shuffleArray<T>(array: T[]) {
 50 | 	for (let i = array.length - 1; i > 0; i--) {
 51 | 		const rand = Math.floor(Math.random() * (i + 1));
 52 | 		[array[i], array[rand]] = [array[rand], array[i]];
 53 | 	}
 54 | }
 55 | 
 56 | /**
 57 |  * 将大的数组拆分成多个小的数组
 58 |  * @param array 源数组
 59 |  * @param chunkSize 拆分出的每组大小上限
 60 |  * @returns 拆分后的二维数组
 61 |  */
 62 | export function splitArray<T>(array: T[], chunkSize: number): T[][] {
 63 | 	const chunks: T[][] = [];
 64 | 	for (let i = 0; i < array.length; i += chunkSize) {
 65 | 		const chunk = array.slice(i, i + chunkSize);
 66 | 		chunks.push(chunk);
 67 | 	}
 68 | 	return chunks;
 69 | }
 70 | 
 71 | /** 获取数组最后一个元素 */
 72 | export function last<T>(array: T[]): T {
 73 | 	return array[array.length - 1];
 74 | }
 75 | 
 76 | /** 获取数组首个元素 */
 77 | export function first<T>(array: T[]): T {
 78 | 	return array[0];
 79 | }
 80 | 
 81 | export function randomRange(min: number, max: number): number {
 82 | 	return Math.random() * (max - min) + min;
 83 | }
 84 | 
 85 | export function wait(duration: number) {
 86 | 	return new Promise(resolve => setTimeout(resolve, duration));
 87 | }
 88 | 
 89 | 
 90 | 
 91 | /** 补齐字符个数 */
 92 | export function pad(str: string | number, len: number, prefix: string = '0') {
 93 | 	str = str.toString();
 94 | 	const count = len - str.length;
 95 | 	if (count <= 0) return str;
 96 | 	return prefix.repeat(count) + str;
 97 | }
 98 | 
 99 | /** 转为16进制数 */
100 | export function toHex(i: number) {
101 | 	const str = i.toString(16);
102 | 	if (i <= 15) return ('0' + str).toUpperCase();
103 | 	return str.toUpperCase();
104 | }
105 | 
106 | 
107 | /**
108 |  * 格式化时间字符串
109 |  * @param seconds 时间长度，单位为秒
110 |  * @param toFixed 精确到秒后多少位
111 |  * @param dayUnit 天数展示方法，用于支持多语言和复数
112 |  * @returns 形如 `1天02:05:43.123`
113 |  */
114 | export function formatTime(seconds: number, toFixed = 0, dayUnit = (days: number) => `${days}天`) {
115 | 	let ret = '';
116 | 	if (seconds >= 86400) {
117 | 		ret += dayUnit(Math.floor(seconds / 86400));
118 | 	}
119 | 	if (seconds >= 3600) {
120 | 		ret += pad(Math.floor(seconds % 86400 / 3600), 2, '0');
121 | 		ret += ':';
122 | 	}
123 | 	if (seconds >= 60) {
124 | 		ret += pad(Math.floor(seconds % 3600 / 60), 2, '0');
125 | 		ret += ':';
126 | 	}
127 | 	if (seconds > 0) {
128 | 		ret += pad(Math.floor(seconds % 60), 2, '0');
129 | 		if (toFixed > 0) {
130 | 			const nano = seconds - Math.floor(seconds);
131 | 			ret += '.' + nano.toFixed(toFixed).substring(2);
132 | 		}
133 | 	}
134 | 	return ret;
135 | }
136 | 
137 | export function sec2msEx(result: number, showM: boolean = true): string {
138 | 	let ms = (result - Math.floor(result)).toFixed(3);
139 | 	ms = ms.split('.')[1];
140 | 	let m = Math.floor(result / 60);
141 | 	let s = Math.floor(result - m * 60);
142 | 	if (showM) {
143 | 		// @ts-expect-error
144 | 		if (m < 10) m = `0${m}`;
145 | 		// @ts-expect-error
146 | 		if (s < 10) s = `0${s}`;
147 | 		return `${m}:${s}.${ms}`;
148 | 	}
149 | 	else return `${s}.${ms}`;
150 | }
151 | 
152 | /**
153 |  * @deprecated 使用 formatTime
154 |  */
155 | export const formatSeconds = formatTime;
156 | 
157 | // 取一个id,weight列表按weight的随机id
158 | export function pickByWeight(list: { id: string, weight: number; }[]) {
159 | 	list = list.filter(v => v.weight > 0);
160 | 	if (list.length === 0) return null;
161 | 	const weightList: number[] = [];
162 | 	let totalWeight = 0;
163 | 	list.forEach(item => {
164 | 		totalWeight += item.weight;
165 | 		weightList.push(totalWeight);
166 | 	});
167 | 	const rand = Math.random() * totalWeight;
168 | 	for (let i = 0; i < weightList.length; i++) {
169 | 		if (rand <= weightList[i]) {
170 | 			return list[i].id;
171 | 		}
172 | 	}
173 | 	return null;
174 | }
175 | 
176 | //插值
177 | export function lerp(x: number, y: number, r: number) {
178 | 	return x + (y - x) * r;
179 | }
180 | 


--------------------------------------------------------------------------------
/src/framework/platform/dev/platform.dev.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable camelcase */
  2 | import { PlatformType } from 'framework/common/constants';
  3 | import { wait } from 'framework/tiny/utils';
  4 | import { DefinePlatfrom } from '../utils';
  5 | import { WebPlatform } from '../web/platform.web';
  6 | import { DevGameRecorder } from './recorder.dev';
  7 | 
  8 | import capsuleHTML from './page/debug-panel.html';
  9 | import iphonexHTML from './page/iphonex.html';
 10 | 
 11 | function applyHtmlTemplate(html: string, root = document.body) {
 12 | 	const div = document.createElement('div');
 13 | 	div.innerHTML = html;
 14 | 	const scripts: HTMLScriptElement[] = [];
 15 | 	const newScripts: HTMLScriptElement[] = [];
 16 | 	div.querySelectorAll('script').forEach(script => {
 17 | 		scripts.push(script);
 18 | 		const newScript = document.createElement('script');
 19 | 		newScript.textContent = script.textContent;
 20 | 		newScripts.push(newScript);
 21 | 	});
 22 | 	scripts.forEach(script => script.remove());
 23 | 	root.appendChild(div);
 24 | 	newScripts.forEach(s => document.body.appendChild(s));
 25 | 	return div;
 26 | }
 27 | 
 28 | export class DevPlatform extends WebPlatform implements Platform {
 29 | 	get type() { return PlatformType.Dev; }
 30 | 
 31 | 	readonly recorder = new DevGameRecorder('idle');
 32 | 	constructor() {
 33 | 		super();
 34 | 		applyHtmlTemplate(capsuleHTML);
 35 | 		applyHtmlTemplate(iphonexHTML);
 36 | 	}
 37 | 
 38 | 
 39 | 	async showMiniGamePanel() {
 40 | 		if (this.$launchOptions.location == 'sidebar_card') this.$launchOptions.location = '';
 41 | 		await getPlatform().accept('打开侧边栏的结果', '模拟打开侧边栏', '成功', '失败');
 42 | 		this.$launchOptions.launch_from = 'homepage';
 43 | 		this.$launchOptions.location = 'sidebar_card';
 44 | 		this.toast('切换程序焦点后可测试侧边栏启动参数');
 45 | 	}
 46 | 
 47 | 
 48 | 	async followProfile() {
 49 | 		await getPlatform().accept('选择关注官方号的结果', '模拟关注官方号', '关注成功', '关注失败');
 50 | 		await this.showLoading('');
 51 | 		await wait(1500);
 52 | 		await this.hideLoading();
 53 | 		localStorage.setItem('platform.followed', 'true');
 54 | 	}
 55 | 
 56 | 	async checkFollowProfile() {
 57 | 		await wait(1000);
 58 | 		return JSON.parse(localStorage.getItem('platform.followed') || 'false');
 59 | 	}
 60 | 
 61 | 	async showUserGeneratedVideo(videoID: string) {
 62 | 		let ret: { data: { gid: string; }; };
 63 | 		try { ret = await this.http.get(`https://gate.snssdk.com/developer/api/get_gid_str?video_id=${videoID}`); } catch (error) {
 64 | 			console.warn('通过抖音获取短视频信息出错', videoID);
 65 | 		}
 66 | 		const video = ret?.data?.gid || videoID;
 67 | 		if (video) {
 68 | 			const url = `https://www.douyin.com/video/${video}`;
 69 | 			await this.accept(`通过抖音网页版查看内容`, '播放抖音短视频', '打开', '取消');
 70 | 			window.open(url, '_blank');
 71 | 		} else {
 72 | 			this.toast('短视频参数有误', 'fail');
 73 | 		}
 74 | 	}
 75 | 
 76 | 	async getUserInfo() {
 77 | 		const cache = this.localStorage.getItem('platform.userinfo');
 78 | 		if (cache) {
 79 | 			return JSON.parse(cache) as IUserInfo;
 80 | 		}
 81 | 		const data = (await this.http.get('https://randomuser.me/api/')).results[0];
 82 | 		const ui = {
 83 | 			nickName: `${data.name.first} ${data.name.last}`,
 84 | 			avatarUrl: data.picture.large.split('?')[0],
 85 | 			gender: data.gender === 'Female' ? 2 : (data.gender === 'Male' ? 1 : 0)
 86 | 		} as IUserInfo;
 87 | 		this.localStorage.setItem('platform.userinfo', JSON.stringify(ui));
 88 | 		return ui;
 89 | 	}
 90 | 
 91 | 	async joinCommunity(community: CommunityInfo) {
 92 | 		await getPlatform().accept(`确认加入群组: ${community.name} ?`, '模拟加粉丝群', '加入', '取消');
 93 | 	}
 94 | 
 95 | 	async getCommunitys(master: IUserInfo) {
 96 | 		await wait(500);
 97 | 		return [
 98 | 			{
 99 | 				type: 'chat-group',
100 | 				name: '轻娱开发内测群',
101 | 				data: {
102 | 					avatar_uri: 'https://files.tinyfun.online/public/misc/group-avatar.jpeg',
103 | 					description: '轻娱游戏内测群，欢迎加入',
104 | 					entry_limit: ['无要求'],
105 | 					exist_num: 487,
106 | 					group_id: 'tiny-group-0001',
107 | 					group_name: '轻娱开发内测群0',
108 | 					max_num: 500,
109 | 					status: 'normal',
110 | 					tags: ['90后', '内测', '开发']
111 | 				}
112 | 			},
113 | 			{
114 | 				type: 'chat-group',
115 | 				name: '轻娱开发内测2群',
116 | 				data: {
117 | 					avatar_uri: 'https://files.tinyfun.online/public/misc/group-avatar.jpeg',
118 | 					description: '轻娱游戏内测群，欢迎加入',
119 | 					entry_limit: ['无要求'],
120 | 					exist_num: 500,
121 | 					group_id: 'tiny-group-0002',
122 | 					group_name: '轻娱开发内测2群',
123 | 					max_num: 500,
124 | 					status: 'full',
125 | 					tags: ['90后', '内测', '开发']
126 | 				}
127 | 			},
128 | 			{
129 | 				type: 'chat-group',
130 | 				name: '轻娱开发内测3群',
131 | 				data: {
132 | 					avatar_uri: 'https://files.tinyfun.online/public/misc/group-avatar.jpeg',
133 | 					description: '轻娱游戏内测群，欢迎加入',
134 | 					entry_limit: ['无要求'],
135 | 					exist_num: 500,
136 | 					group_id: 'tiny-group-0002',
137 | 					group_name: '轻娱开发内测3群',
138 | 					max_num: 500,
139 | 					status: 'ban',
140 | 					tags: ['90后', '内测', '开发']
141 | 				}
142 | 			}
143 | 		];
144 | 	}
145 | 
146 | 	async openCustomerServiceConversation() {
147 | 		await getPlatform().alert(`模拟打开客服会话功能`, '打开客服会话');
148 | 	}
149 | 
150 | }
151 | DefinePlatfrom(DevPlatform);
152 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/xhr.kuaishou.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | import { BodyInit, XMLHttpRequestBase, XMLHttpRequestEventTarget, XMLHttpRequestMethod, XMLHttpRequestReadyState, XMLHttpRequestUpload } from 'framework/webapi/xhr/xhr.common';
  3 | import HttpStatusCode from 'http-status-codes';
  4 | import MIMEType from 'whatwg-mimetype';
  5 | 
  6 | class KSXMLHttpRequest extends XMLHttpRequestBase {
  7 | 	protected $request: ReturnType<typeof ks.request>;
  8 | 	private $status: number;
  9 | 	private $requestResult: { data: string | object | ArrayBuffer; statusCode: number; header: Record<string, string>; };
 10 | 	private $requestError: { errMsg: string; };
 11 | 	private $timeoutUntil: number;
 12 | 
 13 | 	get status(): number {
 14 | 		return this.$status;
 15 | 	}
 16 | 
 17 | 	get responseURL(): string {
 18 | 		if (this.url) return this.url.url;
 19 | 		return null;
 20 | 	}
 21 | 
 22 | 	get responseXML(): string {
 23 | 		return this.responseText;
 24 | 	}
 25 | 
 26 | 	get responseText(): string {
 27 | 		if (!this.$requestResult) return undefined;
 28 | 		if (typeof this.$requestResult.data === 'string') {
 29 | 			return this.$requestResult.data;
 30 | 		} else if (typeof this.$requestResult.data === 'object') {
 31 | 			if (this.$requestResult.data instanceof ArrayBuffer) {
 32 | 				return `[ArrayBuffer(${this.$requestResult.data.byteLength})]`;
 33 | 			} else {
 34 | 				return JSON.stringify(this.$requestResult.data);
 35 | 			}
 36 | 		}
 37 | 		return undefined;
 38 | 	}
 39 | 
 40 | 	getAllResponseHeaders(): string {
 41 | 		let text = '';
 42 | 		if (this.$requestResult && this.$requestResult.header) {
 43 | 			for (const pair of Object.entries(this.$requestResult.header)) {
 44 | 				text += pair.join(': ');
 45 | 			}
 46 | 		}
 47 | 		return text;
 48 | 	}
 49 | 
 50 | 	getResponseHeader(name: string): string {
 51 | 		return this.$requestResult?.header[name] || this.$requestResult?.header[name.toLowerCase()];
 52 | 	}
 53 | 
 54 | 	constructor() {
 55 | 		super();
 56 | 	}
 57 | 
 58 | 	open(method: XMLHttpRequestMethod, url: string, async?: boolean, username?: string | null, password?: string | null): void {
 59 | 		this.$url = parseUrl(url);
 60 | 		this.$status = null;
 61 | 		this.$method = method;
 62 | 		this.$readyState = XMLHttpRequestReadyState.UNSENT;
 63 | 		this.$connectionStartAt = Date.now();
 64 | 	}
 65 | 
 66 | 	send(body?: BodyInit | null): void {
 67 | 		this.$requestResult = null;
 68 | 		this.$requestError = null;
 69 | 		this.readyState = XMLHttpRequestReadyState.OPENED;
 70 | 		this.$status = HttpStatusCode.CONTINUE;
 71 | 		this.$request = ks.request({
 72 | 			url: this.url.url,
 73 | 			method: this.$method as any,
 74 | 			data: body,
 75 | 			dataType: '其他',
 76 | 			header: this.$requestHeaders,
 77 | 			responseType: this.responseType === 'arraybuffer' ? 'arraybuffer' : 'text',
 78 | 			success: ret => this.$requestResult = ret,
 79 | 			fail: err => this.$requestError = err
 80 | 		});
 81 | 		this.readyState = XMLHttpRequestReadyState.LOADING;
 82 | 
 83 | 		if (typeof this.timeout === 'number') {
 84 | 			this.$timeoutUntil = Date.now() + this.timeout;
 85 | 		}
 86 | 		this.$dispatch_event('loadstart');
 87 | 		this.$start_poll();
 88 | 	}
 89 | 
 90 | 	abort(): void {
 91 | 		if (this.$request) {
 92 | 			this.$request.abort();
 93 | 			this.$dispatch_event('abort');
 94 | 			this.$stop_poll();
 95 | 		}
 96 | 	}
 97 | 
 98 | 	protected $getProgress(): ProgressEventInit {
 99 | 		return {
100 | 			lengthComputable: false,
101 | 			loaded: this.$requestResult ? 1 : 0,
102 | 			total: 1
103 | 		};
104 | 	}
105 | 
106 | 	public $tick() {
107 | 		if (this.$request) {
108 | 			if (this.$requestResult) {
109 | 				this.$status = this.$requestResult.statusCode;
110 | 			}
111 | 			if (this.$status) {
112 | 				this.readyState = XMLHttpRequestReadyState.OPENED;
113 | 			}
114 | 
115 | 			const now = Date.now();
116 | 			if (this.$timeoutUntil && now > this.$timeoutUntil) {
117 | 				this.$request.abort();
118 | 				this.$status = HttpStatusCode.REQUEST_TIMEOUT;
119 | 				this.$dispatch_event('timeout');
120 | 				this.$finishedLoad();
121 | 				return;
122 | 			}
123 | 
124 | 			if (this.$requestResult || this.$requestError) {
125 | 				this.$finishedLoad();
126 | 			}
127 | 		}
128 | 	}
129 | 
130 | 	private $finishedLoad() {
131 | 		this.$stop_poll();
132 | 		this.readyState = XMLHttpRequestReadyState.DONE;
133 | 		if (this.$requestResult) {
134 | 			this.$status = this.$requestResult.statusCode;
135 | 			this.$requestHeaders = this.$requestResult.header;
136 | 			this.$processResponse(this.$requestResult.data);
137 | 		}
138 | 		if (this.status == HttpStatusCode.OK) {
139 | 			this.$dispatch_event('progress');
140 | 			this.$dispatch_event('load');
141 | 		} else {
142 | 			this.$dispatch_event('error');
143 | 		}
144 | 		this.$dispatch_event('loadend');
145 | 	}
146 | 
147 | 	protected $processResponse(data: unknown) {
148 | 		if (this.responseType === undefined) {
149 | 			const mime = new MIMEType(this.$overridedMime || this.getResponseHeader('Content-Type') || 'text/plain');
150 | 			if (mime.type === 'application' && mime.subtype === 'json') {
151 | 				this.responseType = 'json';
152 | 			} else if (mime.type === 'text') {
153 | 				this.responseType = 'text';
154 | 			} else if (mime.isXML() || mime.isHTML() || mime.isJavaScript()) {
155 | 				this.responseType = 'text';
156 | 			} else {
157 | 				this.responseType = 'arraybuffer';
158 | 			}
159 | 		}
160 | 		switch (this.responseType) {
161 | 			case '':
162 | 			case 'document':
163 | 			case 'text':
164 | 				this.$response = this.responseText;
165 | 				break;
166 | 			case 'json': {
167 | 				const text = this.responseText;
168 | 				if (text) {
169 | 					this.$response = JSON.parse(text);
170 | 				} else {
171 | 					this.$response = null;
172 | 				}
173 | 			} break;
174 | 			default:
175 | 				this.$response = data;
176 | 				break;
177 | 		}
178 | 	}
179 | }
180 | 
181 | import { globalSet } from 'framework/tiny/core/global';
182 | import { parseUrl } from 'framework/webapi/xhr/url';
183 | globalSet('XMLHttpRequestEventTarget', XMLHttpRequestEventTarget);
184 | globalSet('XMLHttpRequestReadyState', XMLHttpRequestReadyState);
185 | globalSet('XMLHttpRequestUpload', XMLHttpRequestUpload);
186 | globalSet('XMLHttpRequest', KSXMLHttpRequest);
187 | 
188 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/xhr.wechat.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | import { BodyInit, XMLHttpRequestBase, XMLHttpRequestEventTarget, XMLHttpRequestMethod, XMLHttpRequestReadyState, XMLHttpRequestUpload } from 'framework/webapi/xhr/xhr.common';
  3 | import HttpStatusCode from 'http-status-codes';
  4 | import MIMEType from 'whatwg-mimetype';
  5 | 
  6 | class WechatXMLHttpRequest extends XMLHttpRequestBase {
  7 | 	protected $request: ReturnType<typeof wx.request>;
  8 | 	private $status: number;
  9 | 	private $requestResult: { data: string | object | ArrayBuffer; statusCode: number; header: Record<string, string>; };
 10 | 	private $requestError: { errMsg: string; };
 11 | 	private $timeoutUntil: number;
 12 | 
 13 | 	get status(): number {
 14 | 		return this.$status;
 15 | 	}
 16 | 
 17 | 	get responseURL(): string {
 18 | 		if (this.url) return this.url.url;
 19 | 		return null;
 20 | 	}
 21 | 
 22 | 	get responseXML(): string {
 23 | 		return this.responseText;
 24 | 	}
 25 | 
 26 | 	get responseText(): string {
 27 | 		if (!this.$requestResult) return undefined;
 28 | 		if (typeof this.$requestResult.data === 'string') {
 29 | 			return this.$requestResult.data;
 30 | 		} else if (typeof this.$requestResult.data === 'object') {
 31 | 			if (this.$requestResult.data instanceof ArrayBuffer) {
 32 | 				return `[ArrayBuffer(${this.$requestResult.data.byteLength})]`;
 33 | 			} else {
 34 | 				return JSON.stringify(this.$requestResult.data);
 35 | 			}
 36 | 		}
 37 | 		return undefined;
 38 | 	}
 39 | 
 40 | 	getAllResponseHeaders(): string {
 41 | 		let text = '';
 42 | 		if (this.$requestResult && this.$requestResult.header) {
 43 | 			for (const pair of Object.entries(this.$requestResult.header)) {
 44 | 				text += pair.join(': ');
 45 | 			}
 46 | 		}
 47 | 		return text;
 48 | 	}
 49 | 
 50 | 	getResponseHeader(name: string): string {
 51 | 		return this.$requestResult?.header[name] || this.$requestResult?.header[name.toLowerCase()];
 52 | 	}
 53 | 
 54 | 	constructor() {
 55 | 		super();
 56 | 	}
 57 | 
 58 | 	open(method: XMLHttpRequestMethod, url: string, async?: boolean, username?: string | null, password?: string | null): void {
 59 | 		this.$url = parseUrl(url);
 60 | 		this.$status = null;
 61 | 		this.$method = method;
 62 | 		this.$readyState = XMLHttpRequestReadyState.UNSENT;
 63 | 		this.$connectionStartAt = Date.now();
 64 | 	}
 65 | 
 66 | 	send(body?: BodyInit | null): void {
 67 | 		this.$requestResult = null;
 68 | 		this.$requestError = null;
 69 | 		this.readyState = XMLHttpRequestReadyState.OPENED;
 70 | 		this.$status = HttpStatusCode.CONTINUE;
 71 | 		this.$request = wx.request({
 72 | 			url: this.url.url,
 73 | 			method: this.$method as any,
 74 | 			data: body,
 75 | 			dataType: '其他',
 76 | 			header: this.$requestHeaders,
 77 | 			responseType: this.responseType === 'arraybuffer' ? 'arraybuffer' : 'text',
 78 | 			success: ret => this.$requestResult = ret,
 79 | 			fail: err => this.$requestError = err
 80 | 		});
 81 | 		this.readyState = XMLHttpRequestReadyState.LOADING;
 82 | 
 83 | 		if (typeof this.timeout === 'number') {
 84 | 			this.$timeoutUntil = Date.now() + this.timeout;
 85 | 		}
 86 | 		this.$dispatch_event('loadstart');
 87 | 		this.$start_poll();
 88 | 	}
 89 | 
 90 | 	abort(): void {
 91 | 		if (this.$request) {
 92 | 			this.$request.abort();
 93 | 			this.$dispatch_event('abort');
 94 | 			this.$stop_poll();
 95 | 		}
 96 | 	}
 97 | 
 98 | 	protected $getProgress(): ProgressEventInit {
 99 | 		return {
100 | 			lengthComputable: false,
101 | 			loaded: this.$requestResult ? 1 : 0,
102 | 			total: 1
103 | 		};
104 | 	}
105 | 
106 | 	public $tick() {
107 | 		if (this.$request) {
108 | 			if (this.$requestResult) {
109 | 				this.$status = this.$requestResult.statusCode;
110 | 			}
111 | 			if (this.$status) {
112 | 				this.readyState = XMLHttpRequestReadyState.OPENED;
113 | 			}
114 | 
115 | 			const now = Date.now();
116 | 			if (this.$timeoutUntil && now > this.$timeoutUntil) {
117 | 				this.$request.abort();
118 | 				this.$status = HttpStatusCode.REQUEST_TIMEOUT;
119 | 				this.$dispatch_event('timeout');
120 | 				this.$finishedLoad();
121 | 				return;
122 | 			}
123 | 
124 | 			if (this.$requestResult || this.$requestError) {
125 | 				this.$finishedLoad();
126 | 			}
127 | 		}
128 | 	}
129 | 
130 | 	private $finishedLoad() {
131 | 		this.$stop_poll();
132 | 		this.readyState = XMLHttpRequestReadyState.DONE;
133 | 		if (this.$requestResult) {
134 | 			this.$status = this.$requestResult.statusCode;
135 | 			this.$requestHeaders = this.$requestResult.header;
136 | 			this.$processResponse(this.$requestResult.data);
137 | 		}
138 | 		if (this.status == HttpStatusCode.OK) {
139 | 			this.$dispatch_event('progress');
140 | 			this.$dispatch_event('load');
141 | 		} else {
142 | 			this.$dispatch_event('error');
143 | 		}
144 | 		this.$dispatch_event('loadend');
145 | 	}
146 | 
147 | 	protected $processResponse(data: unknown) {
148 | 		if (this.responseType === undefined) {
149 | 			const mime = new MIMEType(this.$overridedMime || this.getResponseHeader('Content-Type') || 'text/plain');
150 | 			if (mime.type === 'application' && mime.subtype === 'json') {
151 | 				this.responseType = 'json';
152 | 			} else if (mime.type === 'text') {
153 | 				this.responseType = 'text';
154 | 			} else if (mime.isXML() || mime.isHTML() || mime.isJavaScript()) {
155 | 				this.responseType = 'text';
156 | 			} else {
157 | 				this.responseType = 'arraybuffer';
158 | 			}
159 | 		}
160 | 		switch (this.responseType) {
161 | 			case '':
162 | 			case 'document':
163 | 			case 'text':
164 | 				this.$response = this.responseText;
165 | 				break;
166 | 			case 'json': {
167 | 				const text = this.responseText;
168 | 				if (text) {
169 | 					this.$response = JSON.parse(text);
170 | 				} else {
171 | 					this.$response = null;
172 | 				}
173 | 			} break;
174 | 			default:
175 | 				this.$response = data;
176 | 				break;
177 | 		}
178 | 	}
179 | }
180 | 
181 | import { globalSet } from 'framework/tiny/core/global';
182 | import { parseUrl } from 'framework/webapi/xhr/url';
183 | if (wx.getSystemInfoSync().platform !== 'devtools') {
184 | 	globalSet('XMLHttpRequestEventTarget', XMLHttpRequestEventTarget);
185 | 	globalSet('XMLHttpRequestReadyState', XMLHttpRequestReadyState);
186 | 	globalSet('XMLHttpRequestUpload', XMLHttpRequestUpload);
187 | 	globalSet('XMLHttpRequest', WechatXMLHttpRequest);
188 | }
189 | 
190 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
  1 | const fs = require('fs');
  2 | const path = require('path');
  3 | const webpack = require('webpack');
  4 | const workspace = path.resolve(__dirname);
  5 | 
  6 | const scriptOutputRoot = 'build/scripts';
  7 | 
  8 | const entries = {
  9 | 	'platform.dev': {
 10 | 		input: 'src/framework/platform/dev/platform.dev.ts',
 11 | 		path: scriptOutputRoot,
 12 | 		filename: 'platform.dev.js'
 13 | 	},
 14 | 	'platform.web': {
 15 | 		input: 'src/framework/platform/web/platform.web.ts',
 16 | 		path: scriptOutputRoot,
 17 | 		filename: 'platform.web.js'
 18 | 	},
 19 | 
 20 | 	'platform.wechat': {
 21 | 		input: 'src/framework/platform/wechat/index.ts',
 22 | 		path: scriptOutputRoot,
 23 | 		filename: 'platform.wechat.js'
 24 | 	},
 25 | 
 26 | 	'platform.kuaishou': {
 27 | 		input: 'src/framework/platform/kuaishou/index.ts',
 28 | 		path: scriptOutputRoot,
 29 | 		filename: 'platform.kuaishou.js'
 30 | 	}
 31 | };
 32 | entries['all'] = Object.values(entries);
 33 | 
 34 | module.exports = (env) => {
 35 | 	if (!env) {
 36 | 		env = {
 37 | 			production: false,
 38 | 			analyze: false,
 39 | 			target: 'es6',
 40 | 			esbuild: true,
 41 | 			entry: 'bundle',
 42 | 			obfuscate: false,
 43 | 			minimize: false,
 44 | 		};
 45 | 	}
 46 | 	env.production = JSON.parse(env.production || 'false');
 47 | 	env.analyze = JSON.parse(env.analyze || 'false');
 48 | 	env.esbuild = JSON.parse(env.esbuild || 'true');
 49 | 	env.entry = env.entry || 'bundle';
 50 | 	env.target = env.target || 'es6';
 51 | 	env.minimize = env.minimize === false || env.minimize === 'false' ? false : env.production;
 52 | 	env.obfuscate = (env.obfuscate == false || env.obfuscate == 'false' || !env.minimize) ? false : env.production;
 53 | 	console.log('Compile config:', env);
 54 | 
 55 | 	if (env.overrideOptions) {
 56 | 		env.overrideOptions = JSON.parse(fs.readFileSync(env.overrideOptions, 'utf-8'));
 57 | 	}
 58 | 
 59 | 	const tsConfigFile = path.join(workspace, 'tsconfig.json');
 60 | 	if (env.target) {
 61 | 		try {
 62 | 			const tsconfig = JSON.parse(fs.readFileSync(tsConfigFile).toString('utf-8'));
 63 | 			tsconfig.compilerOptions.target = env.target;
 64 | 			fs.writeFileSync(tsConfigFile, JSON.stringify(tsconfig, undefined, '\t'));
 65 | 		} catch (error) {
 66 | 			console.warn('修改 tsconfig.json 失败', error?.message);
 67 | 		}
 68 | 	}
 69 | 
 70 | 	const targets = entries[env.entry];
 71 | 	if (!targets) throw new Error(`未找到构建配置: ${env.entry}`);
 72 | 	const options = Array.isArray(targets) ? targets : [targets];
 73 | 	const ret = options.map(option => {
 74 | 		const target = {
 75 | 			entry: [path.join(workspace, option.input)],
 76 | 			output: { path: path.join(workspace, option.path), filename: option.filename },
 77 | 			module: {
 78 | 				rules: [
 79 | 					{ test: /\.(html|md|txt|glsl)$/, use: 'raw-loader' },
 80 | 					{ test: /\.ya?ml$/, use: 'yaml-loader' },
 81 | 					( env.esbuild ?
 82 | 						// esbuild 构建 
 83 | 						{ test: /\.(jsx?|tsx?)$/, loader: 'esbuild-loader', exclude: /(node_modules|bower_components)/, options: { loader: 'tsx' } }
 84 | 						// ts-loader 构建
 85 | 						: { test: /\.tsx?$/, use: 'ts-loader', exclude: /node_modules/ }
 86 | 					),
 87 | 				]
 88 | 			},
 89 | 			plugins: [
 90 | 				// 相当于 C++ 的宏定义，键名会被替换为值的字符串
 91 | 				new webpack.DefinePlugin({
 92 | 					PRODUCTION: JSON.stringify(env.production == true),
 93 | 					BUILD_TIME: JSON.stringify(Date.now()),
 94 | 					RESOURCE_VERSION: JSON.stringify(env.res || ''),
 95 | 					OVERRIDE_OPTIONS: JSON.stringify(env.overrideOptions || {}),
 96 | 				}),
 97 | 				new webpack.ProvidePlugin({ process: 'process/browser' }),
 98 | 				new webpack.ProvidePlugin({ Buffer: ['buffer', 'Buffer'] }),
 99 | 				// ESBuild 不会自动检查TS语法，这里添加相关插件
100 | 				env.esbuild ? new (require('fork-ts-checker-webpack-plugin'))({ typescript: { mode: 'readonly' } }) : null,
101 | 			].filter(p => p != null),
102 | 			devtool: false,
103 | 			resolve: {
104 | 				extensions: ['.tsx', '.ts', '.js', 'glsl', 'md', 'txt'],
105 | 				plugins: [
106 | 					// @ts-ignore
107 | 					new (require('tsconfig-paths-webpack-plugin'))({ configFile: tsConfigFile }),
108 | 				],
109 | 				fallback: { util: require.resolve('util/') }
110 | 			},
111 | 			optimization: {
112 | 				minimize: env.minimize || env.production,
113 | 			},
114 | 			watchOptions: {
115 | 				ignored: /node_modules/,
116 | 			},
117 | 			externals: [
118 | 				{
119 | 					csharp: 'global polyfill:csharp',
120 | 					puerts: 'global polyfill:puerts',
121 | 					path: 'global polyfill:path'
122 | 				},
123 | 				option.externals,
124 | 			].filter(e => e),
125 | 		};
126 | 		target.output.library = { type: 'global', name: '$entry' };
127 | 
128 | 		if (target.target === 'es2020') {
129 | 			target.experiments = { outputModule: true };
130 | 		}
131 | 
132 | 		if (env.production) {
133 | 			target.mode = 'production';
134 | 			if (env.obfuscate) {
135 | 				// TODO: 拆分 obfuscate 流程以确保生成的 SourceMap 是 OK 的
136 | 				target.plugins.push(
137 | 					// @ts-ignore
138 | 					new (require('webpack-obfuscator'))({
139 | 						identifierNamesGenerator: 'mangled-shuffled',
140 | 						reservedNames: [
141 | 							'CS', 'tr', 'tiny',
142 | 							'tinyfunUnityWebGLInstance',
143 | 							'wx', 'tt', 'qg', 'ks',
144 | 							'round', 'ceil', 'sin', 'min', 'max', 'abs', 'floor', 'sqrt', 'pow', 'log', 'exp', 'tan', 'cos', 'asin', 'acos', 'atan', 'atan2', 'random',
145 | 							'foreach', 'map', 'filter'
146 | 						],
147 | 						rotateStringArray: true,
148 | 						sourceMap: true
149 | 					})
150 | 				);
151 | 			}
152 | 			// @ts-expect-error
153 | 			target.plugins.push(new webpack.SourceMapDevToolPlugin({ exclude: /node_modules/, filename: `${option.filename}.map` }));
154 | 		} else {
155 | 			target.cache = { type: 'filesystem' };
156 | 			target.mode = 'development';
157 | 			// @ts-expect-error
158 | 			target.plugins.push(new webpack.SourceMapDevToolPlugin({ exclude: /node_modules/, filename: `development/${option.filename}.map` }));
159 | 			// @ts-expect-error
160 | 			target.plugins.push(new (require('webpackbar'))());
161 | 
162 | 			if (process.env.WEBPACK_SERVE) {
163 | 				target.cache = false;
164 | 				// @ts-expect-error
165 | 				target.plugins.push(new webpack.HotModuleReplacementPlugin());
166 | 				target.devServer = {
167 | 					hot: true,
168 | 					liveReload: false,
169 | 					static: '.',
170 | 					port: 3100,
171 | 					client: {
172 | 						overlay: false,
173 | 						progress: false,
174 | 						reconnect: false,
175 | 					},
176 | 					devMiddleware: {
177 | 						writeToDisk: true,
178 | 					},
179 | 				};
180 | 			}
181 | 		}
182 | 		if (env.analyze) {
183 | 			// @ts-expect-error
184 | 			target.plugins.push(new (require('webpack-bundle-analyzer')).BundleAnalyzerPlugin());
185 | 		}
186 | 		if (env.minimize === false) {
187 | 			target.optimization.minimize = false;
188 | 		}
189 | 		return target;
190 | 	});
191 | 	return ret;
192 | };
193 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/xhr.bytedance.ts:
--------------------------------------------------------------------------------
  1 | import { BodyInit, XMLHttpRequestBase, XMLHttpRequestEventTarget, XMLHttpRequestMethod, XMLHttpRequestReadyState, XMLHttpRequestUpload } from 'framework/webapi/xhr/xhr.common';
  2 | import HttpStatusCode from 'http-status-codes';
  3 | import MIMEType from 'whatwg-mimetype';
  4 | 
  5 | class BytedanceXMLHttpRequest extends XMLHttpRequestBase {
  6 | 	protected $request: tt.RequestTask;
  7 | 	private $status: number;
  8 | 	private $requestResult: tt.RequestResult;
  9 | 	private $requestError: { errMsg: string; };
 10 | 	private $timeoutUntil: number;
 11 | 
 12 | 	get status(): number {
 13 | 		return this.$status;
 14 | 	}
 15 | 
 16 | 	get responseURL(): string {
 17 | 		if (this.url) return this.url.url;
 18 | 		return null;
 19 | 	}
 20 | 
 21 | 	get responseXML(): string {
 22 | 		return this.responseText;
 23 | 	}
 24 | 
 25 | 	get responseText(): string {
 26 | 		if (!this.$requestResult) return undefined;
 27 | 		if (typeof this.$requestResult.data === 'string') {
 28 | 			return this.$requestResult.data;
 29 | 		} else if (typeof this.$requestResult.data === 'object') {
 30 | 			if (this.$requestResult.data instanceof ArrayBuffer) {
 31 | 				return `[ArrayBuffer(${this.$requestResult.data.byteLength})]`;
 32 | 			} else {
 33 | 				return JSON.stringify(this.$requestResult.data);
 34 | 			}
 35 | 		}
 36 | 		return undefined;
 37 | 	}
 38 | 
 39 | 	getAllResponseHeaders(): string {
 40 | 		let text = '';
 41 | 		if (this.$requestResult && this.$requestResult.header) {
 42 | 			for (const pair of Object.entries(this.$requestResult.header)) {
 43 | 				text += pair.join(': ');
 44 | 			}
 45 | 		}
 46 | 		return text;
 47 | 	}
 48 | 
 49 | 	getResponseHeader(name: string): string {
 50 | 		return this.$requestResult?.header[name] || this.$requestResult?.header[name.toLowerCase()];
 51 | 	}
 52 | 
 53 | 	constructor() {
 54 | 		super();
 55 | 	}
 56 | 
 57 | 	open(method: XMLHttpRequestMethod, url: string, async?: boolean, username?: string | null, password?: string | null): void {
 58 | 		this.$url = parseUrl(url);
 59 | 		this.$status = null;
 60 | 		this.$method = method;
 61 | 		this.$readyState = XMLHttpRequestReadyState.UNSENT;
 62 | 		this.$connectionStartAt = Date.now();
 63 | 	}
 64 | 
 65 | 	send(body?: BodyInit | null): void {
 66 | 		this.$requestResult = null;
 67 | 		this.$requestError = null;
 68 | 		this.readyState = XMLHttpRequestReadyState.OPENED;
 69 | 		this.$status = HttpStatusCode.CONTINUE;
 70 | 		this.$request = tt.request({
 71 | 			url: this.url.url,
 72 | 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 73 | 			method: this.$method as any,
 74 | 			data: body,
 75 | 			dataType: 'string',
 76 | 			header: this.$requestHeaders,
 77 | 			responseType: this.responseType === 'arraybuffer' ? 'arraybuffer' : 'text',
 78 | 			success: ret => this.$requestResult = ret,
 79 | 			fail: err => this.$requestError = err
 80 | 		});
 81 | 		this.readyState = XMLHttpRequestReadyState.LOADING;
 82 | 
 83 | 		if (typeof this.timeout === 'number') {
 84 | 			this.$timeoutUntil = Date.now() + this.timeout;
 85 | 		}
 86 | 		this.$dispatch_event('loadstart');
 87 | 		this.$start_poll();
 88 | 	}
 89 | 
 90 | 	abort(): void {
 91 | 		if (this.$request) {
 92 | 			this.$request.abort();
 93 | 			this.$dispatch_event('abort');
 94 | 			this.$stop_poll();
 95 | 		}
 96 | 	}
 97 | 
 98 | 	protected $getProgress(): ProgressEventInit {
 99 | 		return {
100 | 			lengthComputable: false,
101 | 			loaded: this.$requestResult ? 1 : 0,
102 | 			total: 1
103 | 		};
104 | 	}
105 | 
106 | 	public $tick() {
107 | 		if (this.$request) {
108 | 			if (this.$requestResult) {
109 | 				this.$status = this.$requestResult.statusCode;
110 | 			}
111 | 			if (this.$status) {
112 | 				this.readyState = XMLHttpRequestReadyState.OPENED;
113 | 			}
114 | 
115 | 			const now = Date.now();
116 | 			if (this.$timeoutUntil && now > this.$timeoutUntil) {
117 | 				this.$request.abort();
118 | 				this.$status = HttpStatusCode.REQUEST_TIMEOUT;
119 | 				this.$dispatch_event('timeout');
120 | 				this.$finishedLoad();
121 | 				return;
122 | 			}
123 | 
124 | 			if (this.$requestResult || this.$requestError) {
125 | 				this.$finishedLoad();
126 | 			}
127 | 		}
128 | 	}
129 | 
130 | 	private $finishedLoad() {
131 | 		this.$stop_poll();
132 | 		this.readyState = XMLHttpRequestReadyState.DONE;
133 | 		if (this.$requestResult) {
134 | 			this.$status = this.$requestResult.statusCode;
135 | 			this.$requestHeaders = this.$requestResult.header;
136 | 			this.$processResponse(this.$requestResult.data);
137 | 		}
138 | 		if (this.status == HttpStatusCode.OK) {
139 | 			this.$dispatch_event('progress');
140 | 			this.$dispatch_event('load');
141 | 		} else {
142 | 			this.$dispatch_event('error');
143 | 		}
144 | 		this.$dispatch_event('loadend');
145 | 	}
146 | 
147 | 	protected $processResponse(data: unknown) {
148 | 		if (this.responseType === undefined) {
149 | 			const mime = new MIMEType(this.$overridedMime || this.getResponseHeader('Content-Type') || 'text/plain');
150 | 			if (mime.type === 'application' && mime.subtype === 'json') {
151 | 				this.responseType = 'json';
152 | 			} else if (mime.type === 'text') {
153 | 				this.responseType = 'text';
154 | 			} else if (mime.isXML() || mime.isHTML() || mime.isJavaScript()) {
155 | 				this.responseType = 'text';
156 | 			} else {
157 | 				this.responseType = 'arraybuffer';
158 | 			}
159 | 		}
160 | 		switch (this.responseType) {
161 | 			case '':
162 | 			case 'document':
163 | 			case 'text':
164 | 				this.$response = this.responseText;
165 | 				break;
166 | 			case 'json': {
167 | 				const text = this.responseText;
168 | 				if (text) {
169 | 					this.$response = JSON.parse(text);
170 | 				} else {
171 | 					this.$response = null;
172 | 				}
173 | 			} break;
174 | 			default:
175 | 				this.$response = data;
176 | 				break;
177 | 		}
178 | 	}
179 | }
180 | 
181 | import { globalSet } from 'framework/tiny/core/global';
182 | import { parseUrl } from 'framework/webapi/xhr/url';
183 | 
184 | const defineXMLHttpRequest = () => {
185 | 	globalSet('XMLHttpRequestEventTarget', XMLHttpRequestEventTarget);
186 | 	globalSet('XMLHttpRequestReadyState', XMLHttpRequestReadyState);
187 | 	globalSet('XMLHttpRequestUpload', XMLHttpRequestUpload);
188 | 	globalSet('XMLHttpRequest', BytedanceXMLHttpRequest);
189 | };
190 | 
191 | declare const nativeSystemInfo: ReturnType<typeof tt.getSystemInfoSync>;
192 | declare const originalXHR: typeof XMLHttpRequest;
193 | if (typeof document === 'object' && typeof nativeSystemInfo === 'object' && nativeSystemInfo.platform === 'android') {
194 | 	// 安卓平台使用 tt.request
195 | 	defineXMLHttpRequest();
196 | } else if (typeof originalXHR !== 'undefined') {
197 | 	// iOS 平台使用浏览器的 XMLHttpRequest
198 | 	// 抖音小游戏在启动 Unity 前将次功能使用 tt.request 的实现版本对 XHR 进行了替换与我们的实现方案基本一致
199 | 	//   BUG: 怎么能相信抖音在发网络请求的基本实现都能有问题, 在少部分 iOS 设备上请求不成功，报错没联网
200 | 	// 我们在 adaptor 中将浏览器的 XMLHttpRequest 备份了一下，这里执行恢复
201 | 	globalSet('XMLHttpRequest', originalXHR);
202 | }
203 | 
204 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/wx-patch.d.ts:
--------------------------------------------------------------------------------
  1 | declare namespace wx {
  2 | 
  3 | 	interface CreateCustomAdOption {
  4 | 		/** 广告自动刷新的间隔时间，单位为秒，参数值必须大于等于30（仅对支持自动刷新的模板生效） */
  5 | 		adIntervals?: number;
  6 | 		/** 广告单元 id */
  7 | 		adUnitId: string;
  8 | 		/** 原生模板广告组件的样式 */
  9 | 		style: CreateCustomAdStyleOption;
 10 | 	}
 11 | 
 12 | 	/** 原生模板广告组件的样式 */
 13 | 	interface CreateCustomAdStyleOption {
 14 | 		/** (只对小程序适用) 原生模板广告组件是否固定屏幕位置（不跟随屏幕滚动） */
 15 | 		fixed?: boolean;
 16 | 		/** 原生模板广告组件的左上角横坐标 */
 17 | 		left?: number;
 18 | 		width?: number;
 19 | 		/** 原生模板广告组件的左上角纵坐标 */
 20 | 		top?: number;
 21 | 	}
 22 | 
 23 | 	interface CustomAdOnErrorCallbackResult {
 24 | 		/** 需要基础库： `2.2.2`
 25 | 		 *
 26 | 		 * 错误码
 27 | 		 *
 28 | 		 * 可选值：
 29 | 		 * - 1000: 后端接口调用失败;
 30 | 		 * - 1001: 参数错误;
 31 | 		 * - 1002: 广告单元无效;
 32 | 		 * - 1003: 内部错误;
 33 | 		 * - 1004: 无合适的广告;
 34 | 		 * - 1005: 广告组件审核中;
 35 | 		 * - 1006: 广告组件被驳回;
 36 | 		 * - 1007: 广告组件被封禁;
 37 | 		 * - 1008: 广告单元已关闭;
 38 | 		 * - 2001: 模板渲染错误;
 39 | 		 * - 2002: 模板为空;
 40 | 		 * - 2003: 模板解析失败;
 41 | 		 * - 2004: 触发频率限制;
 42 | 		 * - 2005: 触发频率限制; */
 43 | 		errCode:
 44 | 		| 1000
 45 | 		| 1001
 46 | 		| 1002
 47 | 		| 1003
 48 | 		| 1004
 49 | 		| 1005
 50 | 		| 1006
 51 | 		| 1007
 52 | 		| 1008
 53 | 		| 2001
 54 | 		| 2002
 55 | 		| 2003
 56 | 		| 2004
 57 | 		| 2005;
 58 | 		/** 错误信息 */
 59 | 		errMsg: string;
 60 | 	}
 61 | 
 62 | 	/** 原生模板广告组件。原生模板广告组件是一个原生组件，层级比普通组件高。原生模板广告组件默认是隐藏的，需要调用 CustomAd.show() 将其显示。如果宽度可配置，原生模板广告会根据开发者设置的宽度进行等比缩放。 */
 63 | 	interface CustomAd {
 64 | 		/** 原生模板广告组件的样式 */
 65 | 		style: CustomAdStyle;
 66 | 		/** [CustomAd.destroy()](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.destroy.html)
 67 | 		*
 68 | 		* 销毁原生模板广告。 */
 69 | 		destroy(): void;
 70 | 		/** [CustomAd.offClose(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.offClose.html)
 71 | 		 *
 72 | 		 * 取消监听原生模板广告关闭事件 */
 73 | 		offClose(
 74 | 			/** 原生模板广告关闭事件的回调函数 */
 75 | 			callback?: UDPSocketOffCloseCallback
 76 | 		): void;
 77 | 		/** [CustomAd.offError(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.offError.html)
 78 | 		 *
 79 | 		 * 取消监听原生模板广告错误事件 */
 80 | 		offError(
 81 | 			/** 原生模板广告错误事件的回调函数 */
 82 | 			callback?: CustomAdOffErrorCallback
 83 | 		): void;
 84 | 		/** [CustomAd.offHide(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.offHide.html)
 85 | 		 *
 86 | 		 * 需要基础库： `2.14.4`
 87 | 		 *
 88 | 		 * 取消监听原生模板广告隐藏事件 */
 89 | 		offHide(
 90 | 			/** 原生模板广告隐藏事件的回调函数 */
 91 | 			callback?: OffHideCallback
 92 | 		): void;
 93 | 		/** [CustomAd.offLoad(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.offLoad.html)
 94 | 		 *
 95 | 		 * 取消监听原生模板广告加载事件 */
 96 | 		offLoad(
 97 | 			/** 原生模板广告加载事件的回调函数 */
 98 | 			callback?: OffLoadCallback
 99 | 		): void;
100 | 		/** [CustomAd.onClose(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.onClose.html)
101 | 		 *
102 | 		 * 监听原生模板广告关闭事件。 */
103 | 		onClose(
104 | 			/** 原生模板广告关闭事件的回调函数 */
105 | 			callback: UDPSocketOnCloseCallback
106 | 		): void;
107 | 		/** [CustomAd.onError(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.onError.html)
108 | 		 *
109 | 		 * 监听原生模板广告错误事件。
110 | 		 *
111 | 		 * **错误码信息与解决方案表**
112 | 		 *
113 | 		 *  错误码是通过onError获取到的错误信息。调试期间，可以通过异常返回来捕获信息。
114 | 		 *  在小程序发布上线之后，如果遇到异常问题，可以在[“运维中心“](https://mp.weixin.qq.com/)里面搜寻错误日志，还可以针对异常返回加上适当的监控信息。
115 | 		 *
116 | 		 * | 代码 | 异常情况 | 理由 | 解决方案 |
117 | 		 * | ------ | -------------- | --------------- | -------------------------- |
118 | 		 * | 1000  | 后端错误调用失败  | 该项错误不是开发者的异常情况 | 一般情况下忽略一段时间即可恢复。 |
119 | 		 * | 1001  | 参数错误    | 使用方法错误 | 可以前往developers.weixin.qq.com确认具体教程（小程序和小游戏分别有各自的教程，可以在顶部选项中，“设计”一栏的右侧进行切换。|
120 | 		 * | 1002  | 广告单元无效    | 可能是拼写错误、或者误用了其他APP的广告ID | 请重新前往mp.weixin.qq.com确认广告位ID。 |
121 | 		 * | 1003  | 内部错误    | 该项错误不是开发者的异常情况 | 一般情况下忽略一段时间即可恢复。|
122 | 		 * | 1004  | 无适合的广告   | 广告不是每一次都会出现，这次没有出现可能是由于该用户不适合浏览广告 | 属于正常情况，且开发者需要针对这种情况做形态上的兼容。 |
123 | 		 * | 1005  | 广告组件审核中  | 你的广告正在被审核，无法展现广告 | 请前往mp.weixin.qq.com确认审核状态，且开发者需要针对这种情况做形态上的兼容。|
124 | 		 * | 1006  | 广告组件被驳回  | 你的广告审核失败，无法展现广告 | 请前往mp.weixin.qq.com确认审核状态，且开发者需要针对这种情况做形态上的兼容。|
125 | 		 * | 1007  | 广告组件被驳回  | 你的广告能力已经被封禁，封禁期间无法展现广告 | 请前往mp.weixin.qq.com确认小程序广告封禁状态。 |
126 | 		 * | 1008  | 广告单元已关闭  | 该广告位的广告能力已经被关闭 | 请前往mp.weixin.qq.com重新打开对应广告位的展现。|
127 | 		 * | 2001  | 模板渲染错误  | 渲染过程出现错误 | |
128 | 		 * | 2002  | 模板为空  | 该广告位的广告能力已经被关闭 | |
129 | 		 * | 2003  | 模板解析失败  | 该广告位的广告能力已经被关闭 | |
130 | 		 * | 2004  | 触发频率限制  | 小程序启动一定时间内不允许展示原生模板广告 | |
131 | 		 * | 2005  | 触发频率限制  | 距离小程序插屏广告或者激励视频广告上次播放时间间隔不足，不允许展示原生模板广告 | | */
132 | 		onError(
133 | 			/** 原生模板广告错误事件的回调函数 */
134 | 			callback: (res: { errMsg: string; errCode: number; }) => void
135 | 		): void;
136 | 		/** [CustomAd.onHide(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.onHide.html)
137 | 		 *
138 | 		 * 需要基础库： `2.14.4`
139 | 		 *
140 | 		 * 监听原生模板广告隐藏事件, 某些模板如矩阵格子模板用户点击关闭时也会触发该事件。 */
141 | 		onHide(
142 | 			/** 原生模板广告隐藏事件的回调函数 */
143 | 			callback: OnHideCallback
144 | 		): void;
145 | 		/** [CustomAd.onLoad(function callback)](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.onLoad.html)
146 | 		 *
147 | 		 * 监听原生模板广告加载事件。 */
148 | 		onLoad(
149 | 			/** 原生模板广告加载事件的回调函数 */
150 | 			callback: OnLoadCallback
151 | 		): void;
152 | 		/** [Promise CustomAd.hide()](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.hide.html)
153 | 		 *
154 | 		 * 隐藏原生模板广告。（某些模板广告无法隐藏） */
155 | 		hide(): Promise<any>;
156 | 		/** [Promise CustomAd.show()](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.show.html)
157 | 		 *
158 | 		 * 显示原生模板广告。 */
159 | 		show(): Promise<any>;
160 | 		/** [boolean CustomAd.isShow()](https://developers.weixin.qq.com/minigame/dev/api/ad/CustomAd.isShow.html)
161 | 		 *
162 | 		 * 查询原生模板广告展示状态。 */
163 | 		isShow(): boolean;
164 | 	}
165 | 	interface CustomAdOnErrorCallbackResult {
166 | 		/** 需要基础库： `2.2.2`
167 | 		 *
168 | 		 * 错误码
169 | 		 *
170 | 		 * 可选值：
171 | 		 * - 1000: 后端接口调用失败;
172 | 		 * - 1001: 参数错误;
173 | 		 * - 1002: 广告单元无效;
174 | 		 * - 1003: 内部错误;
175 | 		 * - 1004: 无合适的广告;
176 | 		 * - 1005: 广告组件审核中;
177 | 		 * - 1006: 广告组件被驳回;
178 | 		 * - 1007: 广告组件被封禁;
179 | 		 * - 1008: 广告单元已关闭;
180 | 		 * - 2001: 模板渲染错误;
181 | 		 * - 2002: 模板为空;
182 | 		 * - 2003: 模板解析失败;
183 | 		 * - 2004: 触发频率限制;
184 | 		 * - 2005: 触发频率限制; */
185 | 		errCode:
186 | 		| 1000
187 | 		| 1001
188 | 		| 1002
189 | 		| 1003
190 | 		| 1004
191 | 		| 1005
192 | 		| 1006
193 | 		| 1007
194 | 		| 1008
195 | 		| 2001
196 | 		| 2002
197 | 		| 2003
198 | 		| 2004
199 | 		| 2005;
200 | 		/** 错误信息 */
201 | 		errMsg: string;
202 | 	}
203 | 
204 | 	/** 原生模板广告组件的样式 */
205 | 	interface CustomAdStyle {
206 | 		/** (只对小程序适用) 原生模板广告组件是否固定屏幕位置（不跟随屏幕滚动） */
207 | 		fixed: boolean;
208 | 		/** 原生模板广告组件的左上角横坐标 */
209 | 		left: number;
210 | 		/** 原生模板广告组件的左上角纵坐标 */
211 | 		top: number;
212 | 	}
213 | 
214 | 	/** [wx.createCustomAd(Object object)](https://developers.weixin.qq.com/minigame/dev/api/ad/wx.createCustomAd.html)
215 | 	*
216 | 	* 需要基础库： `2.11.1`
217 | 	*
218 | 	* 创建原生模板广告组件。请通过 [wx.getSystemInfoSync()](https://developers.weixin.qq.com/minigame/dev/api/base/system/wx.getSystemInfoSync.html) 返回对象的 SDKVersion 判断基础库版本号 >= 2.11.1 后再使用该 API。每次调用该方法创建原生模板广告都会返回一个全新的实例。 */
219 | 	function createCustomAd(option: CreateCustomAdOption): CustomAd;
220 | }
221 | 


--------------------------------------------------------------------------------
/src/framework/webapi/xhr/webapi.xhr.d.ts:
--------------------------------------------------------------------------------
  1 | //@ts-ignore
  2 | declare module globalThis {
  3 | 	type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "json" | "text";
  4 | 	type XMLHttpRequestMethod = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "HEAD";
  5 | 	type BodyInit = string | Record<string, any>;
  6 | 
  7 | 	interface XMLHttpRequestEventTargetEventMap {
  8 | 		"abort": ProgressEvent<XMLHttpRequestEventTarget>;
  9 | 		"error": ProgressEvent<XMLHttpRequestEventTarget>;
 10 | 		"load": ProgressEvent<XMLHttpRequestEventTarget>;
 11 | 		"loadend": ProgressEvent<XMLHttpRequestEventTarget>;
 12 | 		"loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
 13 | 		"progress": ProgressEvent<XMLHttpRequestEventTarget>;
 14 | 		"timeout": ProgressEvent<XMLHttpRequestEventTarget>;
 15 | 	}
 16 | 
 17 | 	interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
 18 | 		"readystatechange": Event;
 19 | 	}
 20 | 
 21 | 	class XMLHttpRequestEventTarget extends EventTarget {
 22 | 		onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 23 | 		onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 24 | 		onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 25 | 		onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 26 | 		onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 27 | 		onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 28 | 		ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
 29 | 		addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
 30 | 		removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
 31 | 	}
 32 | 
 33 | 	class XMLHttpRequestUpload extends XMLHttpRequestEventTarget {}
 34 | 
 35 | 	enum XMLHttpRequestReadyState {
 36 | 		UNSENT = 0,
 37 | 		OPENED = 1,
 38 | 		HEADERS_RECEIVED = 2,
 39 | 		LOADING = 3,
 40 | 		DONE = 4
 41 | 	}
 42 | 
 43 | 	/** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
 44 | 	class XMLHttpRequest extends XMLHttpRequestEventTarget {
 45 | 		onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
 46 | 		/**
 47 | 		 * Returns client's state.
 48 | 		*/
 49 | 		get readyState(): XMLHttpRequestReadyState;
 50 | 		set readyState(value: XMLHttpRequestReadyState);
 51 | 		protected _readyState: XMLHttpRequestReadyState;
 52 | 		/**
 53 | 			* Returns the response's body.
 54 | 			*/
 55 | 		get response(): any;
 56 | 		protected _response: any;
 57 | 		/**
 58 | 		 * Returns the text response.
 59 | 		 *
 60 | 		 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
 61 | 		*/
 62 | 		readonly responseText: string;
 63 | 		/**
 64 | 		 * Returns the response type.
 65 | 		 *
 66 | 		 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
 67 | 		 *
 68 | 		 * When set: setting to "document" is ignored if current global object is not a Window object.
 69 | 		 *
 70 | 		 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
 71 | 		 *
 72 | 		 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
 73 | 		*/
 74 | 		responseType: XMLHttpRequestResponseType;
 75 | 		readonly responseURL: string;
 76 | 		/**
 77 | 		 * Returns the document response.
 78 | 		 *
 79 | 		 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
 80 | 		*/
 81 | 		readonly responseXML: string | null;
 82 | 		readonly status: number;
 83 | 		readonly statusText: string;
 84 | 		/**
 85 | 		 * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
 86 | 		 *
 87 | 		 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
 88 | 		*/
 89 | 		timeout: number;
 90 | 		/**
 91 | 		 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
 92 | 		*/
 93 | 		get upload(): XMLHttpRequestUpload;
 94 | 		/**
 95 | 		 * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
 96 | 		 *
 97 | 		 * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
 98 | 		*/
 99 | 		withCredentials: boolean;
100 | 		/**
101 | 		 * Cancels any network activity.
102 | 		*/
103 | 		abort(): void;
104 | 		getAllResponseHeaders(): string;
105 | 		getResponseHeader(name: string): string | null;
106 | 		/**
107 | 		 * Sets the request method, request URL, and synchronous flag.
108 | 		 *
109 | 		 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
110 | 		 *
111 | 		 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
112 | 		 *
113 | 		 * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
114 | 		*/
115 | 		open(method: XMLHttpRequestMethod, url: string, async?: boolean, username?: string | null, password?: string | null): void;
116 | 		/**
117 | 		 * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
118 | 		 *
119 | 		 * Throws an "InvalidStateError" DOMException if state is loading or done.
120 | 		*/
121 | 		overrideMimeType(mime: string): void;
122 | 		/**
123 | 		 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
124 | 		 *
125 | 		 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
126 | 		*/
127 | 		send(body?: BodyInit | null): void;
128 | 		/**
129 | 		 * Combines a header in author request headers.
130 | 		 *
131 | 		 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
132 | 		 *
133 | 		 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
134 | 		*/
135 | 		setRequestHeader(name: string, value: string): void;
136 | 		addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
137 | 		removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
138 | 	}
139 | }
140 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/platform.web.basic.ts:
--------------------------------------------------------------------------------
  1 | import FingerprintJS from '@fingerprintjs/fingerprintjs';
  2 | import Bowser from 'bowser';
  3 | import { PlatformType } from 'framework/common/constants';
  4 | import { XHRFileSystem } from 'framework/tiny/utils/fs/fs.xhr';
  5 | import { XHRHttp } from 'framework/tiny/utils/http.xhr';
  6 | import qs from 'qs';
  7 | import SafeAreaInsets from 'safe-area-insets';
  8 | import { GamePlatformBase } from '../platform.common';
  9 | import { DefinePlatfrom } from '../utils';
 10 | import { WebFileDownloader } from './downloader.web';
 11 | import { WebIndexedDBFileSystem } from './fs.web';
 12 | import { TinyWebSocketW3C } from './websocket.web';
 13 | import { globalSet } from 'framework/tiny/core/global';
 14 | import { SizeLimitedFileSystem } from 'framework/tiny/utils/fs/fs.sizelimited';
 15 | import { path } from 'framework/tiny/utils/path';
 16 | 
 17 | globalSet('tr', (text: string) => text);
 18 | 
 19 | export class BasicWebPlatform extends GamePlatformBase implements Platform {
 20 | 
 21 | 	protected $http = new XHRHttp();
 22 | 	get channel(): string { return config.channel; }
 23 | 	get type(): string { return PlatformType.Web; }
 24 | 	get launchOptions() { return this.$launchOptions; }
 25 | 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 26 | 	protected $launchOptions: any = qs.parse(location.search, { ignoreQueryPrefix: true });
 27 | 
 28 | 	get persistentDataPath() { return 'tinyfs://user'; }
 29 | 
 30 | 	protected bowser = Bowser.getParser(window.navigator?.userAgent || 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1');
 31 | 	readonly localStorage = window.localStorage;
 32 | 
 33 | 	constructor() {
 34 | 		super();
 35 | 		window.addEventListener('focus', () => this.setState('focus'), false);
 36 | 		window.addEventListener('blur', () => this.setState('infocus'), false);
 37 | 		document.addEventListener('visibilitychange', () => {
 38 | 			switch (document.visibilityState) {
 39 | 				case 'visible':
 40 | 					this.setState(document.visibilityState);
 41 | 					this.setState('focus');
 42 | 					break;
 43 | 				case 'hidden':
 44 | 					this.emit('infocus');
 45 | 					this.setState(document.visibilityState);
 46 | 					break;
 47 | 			}
 48 | 		}, false);
 49 | 		this.fs.writable.mkdir(this.persistentDataPath, true);
 50 | 	}
 51 | 
 52 | 	get application(): HostApplicationInformation {
 53 | 		return {
 54 | 			name: this.bowser.getBrowserName(),
 55 | 			version: this.bowser.getBrowserVersion(),
 56 | 			SDKVersion: this.bowser.getBrowserVersion(),
 57 | 		};
 58 | 	}
 59 | 
 60 | 	get os(): OSInformation {
 61 | 		return {
 62 | 			name: (this.bowser.getOSName() as OSType || 'unknown').toLowerCase() as OSType,
 63 | 			version: this.bowser.getOSVersion() || 'unknown',
 64 | 		};
 65 | 	}
 66 | 
 67 | 	get device(): DeviceInformation {
 68 | 		return {
 69 | 			model: 'unknown',
 70 | 			brand: 'unknown',
 71 | 			language: this.launchOptions?.lang || navigator.language,
 72 | 			screen: {
 73 | 				width: window.screen.width,
 74 | 				height: window.screen.height,
 75 | 				pixelRatio: window.devicePixelRatio,
 76 | 				dpi: this.getDPI(),
 77 | 			},
 78 | 			window: {
 79 | 				width: window.innerWidth,
 80 | 				height: window.innerHeight,
 81 | 				safeArea: {
 82 | 					left: SafeAreaInsets.left,
 83 | 					right: SafeAreaInsets.right,
 84 | 					top: SafeAreaInsets.top,
 85 | 					bottom: SafeAreaInsets.bottom,
 86 | 					width: window.innerWidth - SafeAreaInsets.left - SafeAreaInsets.right,
 87 | 					height: window.innerHeight - SafeAreaInsets.top - SafeAreaInsets.bottom
 88 | 				}
 89 | 			}
 90 | 		};
 91 | 	}
 92 | 
 93 | 	protected getDPI() {
 94 | 		const div = document.createElement('div');
 95 | 		div.style.height = '1in';
 96 | 		div.style.width = '1in';
 97 | 		div.style.top = '-100%';
 98 | 		div.style.left = '-100%';
 99 | 		div.style.position = 'absolute';
100 | 		document.body.appendChild(div);
101 | 		const result = div.offsetHeight;
102 | 		document.body.removeChild(div);
103 | 		return result;
104 | 	}
105 | 
106 | 	vibrate(durationMs: number): void {
107 | 		if (window.navigator.vibrate) window.navigator.vibrate(durationMs);
108 | 	}
109 | 
110 | 	reload(): Promise<void> {
111 | 		return new Promise((resolve, reject) => {
112 | 			window.location.reload();
113 | 			resolve();
114 | 		});
115 | 	}
116 | 
117 | 	exit(): Promise<void> {
118 | 		return new Promise((resolve, reject) => {
119 | 			window.open('/', '_self', '');
120 | 			window.close();
121 | 		});
122 | 	}
123 | 
124 | 	async getDeviceID(): Promise<string> {
125 | 		const a = await FingerprintJS.load();
126 | 		const ret = await a.get();
127 | 		return ret ? ret.visitorId : undefined;
128 | 	}
129 | 
130 | 	/** 获取剪切板内容 */
131 | 	getClipboardData(): Promise<string> {
132 | 		return navigator.clipboard.readText();
133 | 	}
134 | 	/** 设置剪切板内容 */
135 | 	setClipboardData(data: string): Promise<void> {
136 | 		try {
137 | 			navigator.clipboard.writeText(data);
138 | 			return Promise.resolve();
139 | 		} catch (error) {
140 | 			console.warn(tr('设置剪切板内容出错'));
141 | 			return Promise.reject(error);
142 | 		}
143 | 	}
144 | 
145 | 	async hideSplash(): Promise<void> {
146 | 		const splash = document.getElementById('splash');
147 | 		if (splash) splash.parentNode.removeChild(splash);
148 | 	}
149 | 
150 | 	async login(): Promise<{ code?: string, token?: string, authCode?: string, anonymousCode?: string; game_token?: string; gameUserId?: string; }> {
151 | 		return { code: await this.getDeviceID() };
152 | 	}
153 | 
154 | 	async selectFiles(type: 'image' | 'video' | 'audio' | 'file', options: { multiple?: boolean; accept?: string; } = {}): Promise<string[]> {
155 | 		const input = document.createElement('input');
156 | 		input.type = 'file';
157 | 		input.multiple = options.multiple;
158 | 		let accept = options.accept;
159 | 		if (!accept) {
160 | 			switch (type) {
161 | 				case 'image':
162 | 					accept = 'image/*';
163 | 					break;
164 | 				case 'audio':
165 | 					accept = 'audio/*';
166 | 					break;
167 | 				case 'video':
168 | 					accept = 'video/*';
169 | 					break;
170 | 				case 'file':
171 | 				default:
172 | 					accept = '*/*';
173 | 					break;
174 | 			}
175 | 		}
176 | 		input.accept = accept;
177 | 		input.click();
178 | 		return new Promise((resolve, reject) => {
179 | 			input.onchange = () => {
180 | 				resolve(Array.from(input.files).map(file => URL.createObjectURL(input.files[0])));
181 | 			};
182 | 			input.oncancel = () => reject(new Error(tr('用户取消操作')));
183 | 		});
184 | 	}
185 | 
186 | 	get fs() {
187 | 		if (!this.$fs) {
188 | 			this.$fs = {
189 | 				readonly: this.wrapReadonlyFS(new XHRFileSystem('')),
190 | 				writable: new SizeLimitedFileSystem(
191 | 					new WebIndexedDBFileSystem('fs.writable', this.persistentDataPath),
192 | 					{
193 | 						verbose: !PRODUCTION,
194 | 						maxSize: 512 * 1000 * 1000,
195 | 						reservedSize: 16 * 1000 * 1000,
196 | 						storage: this.localStorage,
197 | 						root: this.persistentDataPath,
198 | 						retainFiles: [
199 | 							path.join(this.persistentDataPath, 'tinysdk.localStorage.bin'),
200 | 						],
201 | 						metaFile: path.join(this.persistentDataPath, 'fs.writable.json'),
202 | 					}
203 | 				),
204 | 			};
205 | 		}
206 | 		return this.$fs;
207 | 	}
208 | 	protected $fs: { readonly?: IReadonlyFilesSystem; writable?: IFilesSystem; };
209 | 
210 | 	WebSocket = typeof WebSocket !== 'undefined' ? TinyWebSocketW3C : undefined;
211 | 
212 | 	get downloader() {
213 | 		if (!this.$downloader) {
214 | 			this.$downloader = new WebFileDownloader(this.fs.writable);
215 | 		}
216 | 		return this.$downloader;
217 | 	}
218 | 	protected $downloader: IFileDownloader;
219 | }
220 | DefinePlatfrom(BasicWebPlatform);
221 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/fs.kuaishou.ts:
--------------------------------------------------------------------------------
  1 | import { path } from 'framework/tiny/utils/path';
  2 | import { SubPackageLoader } from '../utils/SubPackageLoader';
  3 | 
  4 | const fs = ks.getFileSystemManager();
  5 | const REVERSED_DIRS = [
  6 | 	ks.env.USER_DATA_PATH,
  7 | 	'ksfile://temp'
  8 | ];
  9 | 
 10 | export class KuaishouFileSystem implements IFilesSystem {
 11 | 	constructor(readonly name: string) { }
 12 | 
 13 | 	async exists(filePath: string): Promise<boolean> {
 14 | 		try {
 15 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 16 | 			fs.accessSync(filePath);
 17 | 			return true;
 18 | 		} catch (error) {
 19 | 			return false;
 20 | 		}
 21 | 	}
 22 | 
 23 | 	existsSync(filePath: string): boolean {
 24 | 		try {
 25 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 26 | 			fs.accessSync(filePath);
 27 | 			return true;
 28 | 		} catch (error) {
 29 | 			return false;
 30 | 		}
 31 | 	}
 32 | 
 33 | 	stat(filePath: string): Promise<Stat> {
 34 | 		return new Promise((resolve, reject) => {
 35 | 			if (REVERSED_DIRS.includes(filePath)) {
 36 | 				resolve({
 37 | 					size: 0,
 38 | 					lastModifiedTime: 0,
 39 | 					isFile() { return false; },
 40 | 					isDirectory() { return true; }
 41 | 				});
 42 | 				return;
 43 | 			} else {
 44 | 				const inpkgFile = config.assets.files[filePath];
 45 | 				if (inpkgFile) {
 46 | 					resolve({
 47 | 						size: inpkgFile.size,
 48 | 						lastModifiedTime: inpkgFile.mtime,
 49 | 						isDirectory() { return false; },
 50 | 						isFile() { return true; }
 51 | 					});
 52 | 				} else {
 53 | 					fs.stat({
 54 | 						path: filePath,
 55 | 						success: (ret) => resolve(ret.stats as ks.Stats),
 56 | 						fail: reject
 57 | 					});
 58 | 				}
 59 | 			}
 60 | 		});
 61 | 	}
 62 | 
 63 | 	statSync(filePath: string): Stat {
 64 | 		if (REVERSED_DIRS.includes(filePath)) {
 65 | 			return {
 66 | 				size: 0,
 67 | 				lastModifiedTime: 0,
 68 | 				isFile() { return false; },
 69 | 				isDirectory() { return true; }
 70 | 			};
 71 | 		}
 72 | 		const inpkgFile = config.assets.files[filePath];
 73 | 		if (inpkgFile) {
 74 | 			return {
 75 | 				size: inpkgFile.size,
 76 | 				lastModifiedTime: inpkgFile.mtime,
 77 | 				isDirectory() { return false; },
 78 | 				isFile() { return true; }
 79 | 			};
 80 | 		} else {
 81 | 			const ret = fs.statSync(filePath, false);
 82 | 			return ret as ks.Stats;
 83 | 		}
 84 | 	}
 85 | 
 86 | 	unlink(filePath: string): Promise<void> {
 87 | 		return new Promise((resolve, reject) => {
 88 | 			fs.unlink({ filePath, success: resolve, fail: reject });
 89 | 		});
 90 | 	}
 91 | 
 92 | 	rename(oldPath: string, newPath: string): Promise<void> {
 93 | 		return new Promise((resolve, reject) => {
 94 | 			fs.rename({ oldPath, newPath, success: resolve, fail: reject });
 95 | 		});
 96 | 	}
 97 | 
 98 | 	async mkdir(dirPath: string, recursive: boolean): Promise<void> {
 99 | 		if (this.existsSync(dirPath)) return;
100 | 		await fs.mkdirSync(dirPath, recursive);
101 | 	}
102 | 
103 | 	mkdirSync(dirPath: string, recursive: boolean) {
104 | 		if (this.existsSync(dirPath)) return;
105 | 		fs.mkdirSync(dirPath, recursive);
106 | 	}
107 | 
108 | 	rmdir(dirPath: string, recursive: boolean): Promise<void> {
109 | 		return new Promise((resolve, reject) => {
110 | 			fs.rmdir({ dirPath, recursive, success: resolve, fail: reject });
111 | 		});
112 | 	}
113 | 
114 | 	readdir(dirPath: string): Promise<string[]> {
115 | 		return new Promise((resolve, reject) => {
116 | 			dirPath = dirPath.endsWith('/') ? dirPath : dirPath + '/';
117 | 			fs.readdir({
118 | 				dirPath,
119 | 				success: (ret) => resolve(ret.files),
120 | 				fail: reject
121 | 			});
122 | 		});
123 | 	}
124 | 
125 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
126 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
127 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): Promise<string | ArrayBuffer> {
128 | 		const params = { filePath };
129 | 		if (encoding !== 'binary') Object.assign(params, { encoding });
130 | 		return new Promise((resolve, reject) => {
131 | 			fs.readFile({
132 | 				...params,
133 | 				success: (ret) => {
134 | 					resolve(ret.data);
135 | 				},
136 | 				fail: (err) => {
137 | 					reject(new Error('读取文件出错: ' + filePath));
138 | 				}
139 | 			});
140 | 		});
141 | 	}
142 | 
143 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
144 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
145 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): string | ArrayBuffer {
146 | 		return fs.readFileSync(filePath, encoding === 'binary' ? undefined : encoding);
147 | 	}
148 | 
149 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
150 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
151 | 	writeFile(filePath: string, data: string | ArrayBuffer, encoding: string): Promise<void> {
152 | 		return new Promise((resolve, reject) => {
153 | 			fs.writeFile({
154 | 				filePath,
155 | 				encoding: encoding as 'utf8',
156 | 				data,
157 | 				success: resolve,
158 | 				fail: reject
159 | 			});
160 | 		});
161 | 	}
162 | 
163 | 	writeFileSync(filePath: string, data: ArrayBuffer, encoding: 'binary'): void;
164 | 	writeFileSync(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): void;
165 | 	writeFileSync(filePath: string, data: string | ArrayBuffer, encoding: string): void {
166 | 		return fs.writeFileSync(filePath, data, encoding as 'utf8');
167 | 	}
168 | 
169 | 	copyFile(srcPath: string, destPath: string): Promise<void> {
170 | 		return new Promise((resolve, reject) => {
171 | 			fs.copyFile({ srcPath, destPath, success: resolve, fail: reject });
172 | 		});
173 | 	}
174 | }
175 | 
176 | export class KuaishouInPackageFileSystem extends KuaishouFileSystem {
177 | 	readonly subpackages?: ISubPackage[] = [];
178 | 
179 | 	constructor(readonly root = '') {
180 | 		super(root);
181 | 		this.subpackages = config.subpackages || [];
182 | 	}
183 | 
184 | 	exists(filePath: string): Promise<boolean> {
185 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
186 | 		if (config.assets.files[filePath]) {
187 | 			return Promise.resolve(true);
188 | 		}
189 | 		return super.exists(filePath);
190 | 	}
191 | 
192 | 	existsSync(filePath: string): boolean {
193 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
194 | 		if (config.assets.files[filePath]) {
195 | 			return true;
196 | 		}
197 | 		return super.existsSync(filePath);
198 | 	}
199 | 
200 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
201 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
202 | 	async readFile(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): Promise<string | ArrayBuffer> {
203 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
204 | 		await this.loadSubpackage(filePath);
205 | 		return super.readFile(filePath, encoding as 'utf8');
206 | 	}
207 | 
208 | 	protected async loadSubpackage(filePath: string) {
209 | 		return new Promise<void>((resolve, reject) => {
210 | 			if (filePath[0] === '/') filePath = filePath.substring(1);
211 | 			const pkg = (this.subpackages || []).find(p => filePath.startsWith(p.root));
212 | 			if (pkg) {
213 | 				const loader = new SubPackageLoader(pkg);
214 | 				loader.verbose = config.verbose;
215 | 				const clear = () => loader.dispose();
216 | 				loader.event.once('done', () => {
217 | 					clear();
218 | 					resolve();
219 | 				});
220 | 				loader.event.once('failed', (err) => {
221 | 					clear();
222 | 					reject(err);
223 | 				});
224 | 				loader.start();
225 | 			} else {
226 | 				resolve();
227 | 			}
228 | 		});
229 | 	}
230 | 
231 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
232 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
233 | 	readFileSync(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): string | ArrayBuffer {
234 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
235 | 		return super.readFileSync(filePath, encoding as 'utf8');
236 | 	}
237 | }
238 | 


--------------------------------------------------------------------------------
/src/framework/platform/bytedance/fs.bytedance.ts:
--------------------------------------------------------------------------------
  1 | import { path } from 'framework/tiny/utils/path';
  2 | const fs = tt.getFileSystemManager();
  3 | /** 调用头条的异步API */
  4 | function callAsyncApi<T, R>(api: (options: AsyncCallbackOptions<R> & T) => void, options: T): Promise<R> {
  5 | 	return new Promise((resolve, reject) => {
  6 | 		const params: AsyncCallbackOptions = {
  7 | 			success: (ret: R) => resolve(ret),
  8 | 			fail: (err: { errMsg: string; }) => reject(err),
  9 | 			...options
 10 | 		};
 11 | 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 12 | 		api.call(fs, params as any);
 13 | 	});
 14 | }
 15 | 
 16 | export const DouyinFileSystem = {
 17 | 	USER_DATA_PATH: 'scfile://user',
 18 | 	PACKAGE_DATA_PATH: 'scfile://pkg',
 19 | 	TEMP_DATA_PATH: 'scfile://temp'
 20 | };
 21 | 
 22 | const REVERSED_DIRS = [
 23 | 	DouyinFileSystem.USER_DATA_PATH,
 24 | 	DouyinFileSystem.PACKAGE_DATA_PATH,
 25 | 	DouyinFileSystem.TEMP_DATA_PATH
 26 | ];
 27 | 
 28 | export class BytedanceFileSystem implements IFilesSystem, ISyncReadonlyFilesSystem {
 29 | 	constructor(readonly name: string) {
 30 | 		for (const reversed of REVERSED_DIRS.slice()) {
 31 | 			if (!this.existsSync(reversed)) {
 32 | 				REVERSED_DIRS.splice(REVERSED_DIRS.indexOf(reversed), 1);
 33 | 			}
 34 | 		}
 35 | 	}
 36 | 
 37 | 	async exists(filePath: string): Promise<boolean> {
 38 | 		try {
 39 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 40 | 			await callAsyncApi(fs.access, { path: filePath });
 41 | 			return true;
 42 | 		} catch (error) {
 43 | 			return false;
 44 | 		}
 45 | 	}
 46 | 
 47 | 	existsSync(filePath: string): boolean {
 48 | 		try {
 49 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 50 | 			fs.accessSync(filePath);
 51 | 			return true;
 52 | 		} catch (error) {
 53 | 			return false;
 54 | 		}
 55 | 	}
 56 | 
 57 | 	async stat(filePath: string): Promise<Stat> {
 58 | 		if (REVERSED_DIRS.includes(filePath)) {
 59 | 			return {
 60 | 				size: 0,
 61 | 				lastModifiedTime: 0,
 62 | 				isFile() { return false; },
 63 | 				isDirectory() { return true; }
 64 | 			};
 65 | 		}
 66 | 		const inpkgFile = config.assets.files[filePath];
 67 | 		if (inpkgFile) {
 68 | 			return {
 69 | 				size: inpkgFile.size,
 70 | 				lastModifiedTime: inpkgFile.mtime,
 71 | 				isDirectory() { return false; },
 72 | 				isFile() { return true; }
 73 | 			};
 74 | 		} else {
 75 | 			const ret = await callAsyncApi(fs.stat, { path: filePath });
 76 | 			const stat = ret.stat || ret.stats;
 77 | 			stat.size = stat.size || 1;
 78 | 			return stat;
 79 | 		}
 80 | 	}
 81 | 
 82 | 	statSync(filePath: string): Stat {
 83 | 		if (REVERSED_DIRS.includes(filePath)) {
 84 | 			return {
 85 | 				size: 0,
 86 | 				lastModifiedTime: 0,
 87 | 				isFile() { return false; },
 88 | 				isDirectory() { return true; }
 89 | 			};
 90 | 		}
 91 | 		const inpkgFile = config.assets.files[filePath];
 92 | 		if (inpkgFile) {
 93 | 			return {
 94 | 				size: inpkgFile.size,
 95 | 				lastModifiedTime: inpkgFile.mtime,
 96 | 				isDirectory() { return false; },
 97 | 				isFile() { return true; }
 98 | 			};
 99 | 		} else {
100 | 			const ret = fs.statSync(filePath);
101 | 			return ret;
102 | 		}
103 | 	}
104 | 
105 | 	unlink(filePath: string): Promise<void> {
106 | 		return callAsyncApi(fs.unlink, { filePath });
107 | 	}
108 | 
109 | 	rename(oldPath: string, newPath: string): Promise<void> {
110 | 		return callAsyncApi(fs.rename, { oldPath, newPath });
111 | 	}
112 | 
113 | 	/** 抖音小游戏在启动游戏时批量加载资源可能导致重复创建目录而报错，这里启用同步操作 */
114 | 	async mkdir(dirPath: string, recursive: boolean, forceSync = true): Promise<void> {
115 | 		if (this.existsSync(dirPath)) return;
116 | 		if (recursive) {
117 | 			const dirs = [] as string[];
118 | 			let dir = dirPath;
119 | 			let exists = await this.exists(dir);
120 | 			while (dir && !exists) {
121 | 				dirs.push(dir);
122 | 				dir = path.dirname(dir);
123 | 				exists = this.existsSync(dir);
124 | 			}
125 | 			dirs.reverse();
126 | 			for (const dir of dirs) {
127 | 				if (forceSync) {
128 | 					fs.mkdirSync(dir);
129 | 				} else {
130 | 					await callAsyncApi(fs.mkdir, { dirPath: dir });
131 | 				}
132 | 			}
133 | 		} else {
134 | 			if (forceSync) {
135 | 				fs.mkdirSync(dirPath);
136 | 			} else {
137 | 				await callAsyncApi(fs.mkdir, { dirPath });
138 | 			}
139 | 		}
140 | 	}
141 | 
142 | 	async mkdirSync(dirPath: string, recursive: boolean) {
143 | 		if (this.existsSync(dirPath)) return;
144 | 		if (recursive) {
145 | 			const dirs = [] as string[];
146 | 			let dir = dirPath;
147 | 			let exists = await this.exists(dir);
148 | 			while (dir && !exists) {
149 | 				dirs.push(dir);
150 | 				dir = path.dirname(dir);
151 | 				exists = await this.exists(dir);
152 | 			}
153 | 			dirs.reverse();
154 | 			for (const dir of dirs) {
155 | 				fs.mkdirSync(dir);
156 | 			}
157 | 		} else {
158 | 			fs.mkdirSync(dirPath);
159 | 		}
160 | 	}
161 | 
162 | 	async rmdir(dirPath: string, recursive: boolean, forceSync = true): Promise<void> {
163 | 		if (forceSync) {
164 | 			fs.mkdirSync(dirPath);
165 | 		} else {
166 | 			await callAsyncApi(fs.rmdir, { dirPath, recursive });
167 | 		}
168 | 	}
169 | 
170 | 	async readdir(dirPath: string): Promise<string[]> {
171 | 		dirPath = dirPath.endsWith('/') ? dirPath : dirPath + '/';
172 | 		const ret = await callAsyncApi(fs.readdir, { dirPath });
173 | 		return ret.files;
174 | 	}
175 | 
176 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
177 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
178 | 	async readFile(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): Promise<string | ArrayBuffer> {
179 | 		const ret = await callAsyncApi(fs.readFile, { filePath, encoding: encoding === 'binary' ? undefined : encoding });
180 | 		return ret.data;
181 | 	}
182 | 
183 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
184 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
185 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): string | ArrayBuffer {
186 | 		return fs.readFileSync(filePath, encoding === 'binary' ? undefined : encoding);
187 | 	}
188 | 
189 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
190 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
191 | 	writeFile(filePath: string, data: string | ArrayBuffer, encoding: string): Promise<void> {
192 | 		return callAsyncApi(fs.writeFile, { filePath, data, encoding });
193 | 	}
194 | 	writeFileSync(filePath: string, data: ArrayBuffer, encoding: 'binary'): void;
195 | 	writeFileSync(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): void;
196 | 	writeFileSync(filePath: string, data: string | ArrayBuffer, encoding: string): void {
197 | 		return fs.writeFileSync(filePath, data, encoding);
198 | 	}
199 | 
200 | 	copyFile(srcPath: string, destPath: string): Promise<void> {
201 | 		return callAsyncApi(fs.copyFile, { srcPath, destPath });
202 | 	}
203 | }
204 | 
205 | 
206 | export class BytedanceInPackageFileSystem extends BytedanceFileSystem {
207 | 
208 | 	constructor(readonly root: string = '') {
209 | 		super('fs.readonly');
210 | 	}
211 | 
212 | 	exists(filePath: string): Promise<boolean> {
213 | 		filePath = path.join(this.root, filePath);
214 | 		if (config.assets.files[filePath]) {
215 | 			return Promise.resolve(true);
216 | 		}
217 | 		return super.exists(filePath);
218 | 	}
219 | 
220 | 	existsSync(filePath: string): boolean {
221 | 		filePath = path.join(this.root, filePath);
222 | 		if (config.assets.files[filePath]) {
223 | 			return true;
224 | 		}
225 | 		return super.existsSync(filePath);
226 | 	}
227 | 
228 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
229 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
230 | 	async readFile(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): Promise<string | ArrayBuffer> {
231 | 		filePath = path.join(this.root, filePath);
232 | 		return super.readFile(filePath, encoding as 'utf8');
233 | 	}
234 | 
235 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
236 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
237 | 	readFileSync(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): string | ArrayBuffer {
238 | 		filePath = path.join(this.root, filePath);
239 | 		return super.readFileSync(filePath, encoding as 'utf8');
240 | 	}
241 | }
242 | 


--------------------------------------------------------------------------------
/src/framework/platform/wechat/fs.wechat.ts:
--------------------------------------------------------------------------------
  1 | import { path } from 'framework/tiny/utils/path';
  2 | import { SubPackageLoader } from '../utils/SubPackageLoader';
  3 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
  4 | declare interface AsyncCallbackOptions<T = any> {
  5 | 	success?(ret: T): void;
  6 | 	fail?(err: { errMsg: string; }): void;
  7 | 	complete?(): void;
  8 | }
  9 | const fs = wx.getFileSystemManager();
 10 | 
 11 | /** 调用微信的异步API */
 12 | function callAsyncApi<T, R>(api: (options: AsyncCallbackOptions<R> & T) => void, options: T): Promise<R> {
 13 | 	return new Promise((resolve, reject) => {
 14 | 		const params: AsyncCallbackOptions = {
 15 | 			success: (ret: R) => resolve(ret),
 16 | 			fail: (err: { errMsg: string; }) => reject(err),
 17 | 			...options
 18 | 		};
 19 | 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 20 | 		api.call(fs, params as any);
 21 | 	});
 22 | }
 23 | 
 24 | const REVERSED_DIRS = [
 25 | 	wx.env.USER_DATA_PATH,
 26 | 	'wxfile://temp'
 27 | ];
 28 | 
 29 | export class WechatFileSystem implements IFilesSystem {
 30 | 	constructor(readonly name: string) { }
 31 | 
 32 | 	async exists(filePath: string): Promise<boolean> {
 33 | 		try {
 34 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 35 | 			await callAsyncApi(fs.access, { path: filePath });
 36 | 			return true;
 37 | 		} catch (error) {
 38 | 			return false;
 39 | 		}
 40 | 	}
 41 | 
 42 | 	existsSync(filePath: string): boolean {
 43 | 		try {
 44 | 			if (REVERSED_DIRS.includes(filePath)) return true;
 45 | 			fs.accessSync(filePath);
 46 | 			return true;
 47 | 		} catch (error) {
 48 | 			return false;
 49 | 		}
 50 | 	}
 51 | 
 52 | 	async stat(filePath: string): Promise<Stat> {
 53 | 		if (REVERSED_DIRS.includes(filePath)) {
 54 | 			return {
 55 | 				size: 0,
 56 | 				lastModifiedTime: 0,
 57 | 				isFile() { return false; },
 58 | 				isDirectory() { return true; }
 59 | 			};
 60 | 		}
 61 | 		const inpkgFile = config.assets.files[filePath];
 62 | 		if (inpkgFile) {
 63 | 			return {
 64 | 				size: inpkgFile.size,
 65 | 				lastModifiedTime: inpkgFile.mtime,
 66 | 				isDirectory() { return false; },
 67 | 				isFile() { return true; }
 68 | 			};
 69 | 		} else {
 70 | 			const ret = await callAsyncApi(fs.stat, { path: filePath });
 71 | 			const stat = ret.stats as wx.Stats;
 72 | 			stat.size = stat.size || 1;
 73 | 			return stat;
 74 | 		}
 75 | 	}
 76 | 
 77 | 	statSync(filePath: string): Stat {
 78 | 		if (REVERSED_DIRS.includes(filePath)) {
 79 | 			return {
 80 | 				size: 0,
 81 | 				lastModifiedTime: 0,
 82 | 				isFile() { return false; },
 83 | 				isDirectory() { return true; }
 84 | 			};
 85 | 		}
 86 | 		const inpkgFile = config.assets.files[filePath];
 87 | 		if (inpkgFile) {
 88 | 			return {
 89 | 				size: inpkgFile.size,
 90 | 				lastModifiedTime: inpkgFile.mtime,
 91 | 				isDirectory() { return false; },
 92 | 				isFile() { return true; }
 93 | 			};
 94 | 		} else {
 95 | 			const ret = fs.statSync(filePath, false);
 96 | 			return ret as wx.Stats;
 97 | 		}
 98 | 	}
 99 | 
100 | 	async unlink(filePath: string): Promise<void> {
101 | 		await callAsyncApi(fs.unlink, { filePath });
102 | 	}
103 | 
104 | 	async rename(oldPath: string, newPath: string): Promise<void> {
105 | 		await callAsyncApi(fs.rename, { oldPath, newPath });
106 | 	}
107 | 
108 | 	async mkdir(dirPath: string, recursive: boolean): Promise<void> {
109 | 		if (this.existsSync(dirPath)) return;
110 | 		await callAsyncApi(fs.mkdir, { dirPath, recursive });
111 | 	}
112 | 
113 | 	mkdirSync(dirPath: string, recursive: boolean) {
114 | 		if (this.existsSync(dirPath)) return;
115 | 		if (recursive) {
116 | 			const dirs = [] as string[];
117 | 			let dir = dirPath;
118 | 			let exists = this.existsSync(dir);
119 | 			while (dir && !exists) {
120 | 				dirs.push(dir);
121 | 				dir = path.dirname(dir);
122 | 				exists = this.existsSync(dir);
123 | 			}
124 | 			dirs.reverse();
125 | 			for (const dir of dirs) {
126 | 				fs.mkdirSync(dir);
127 | 			}
128 | 		} else {
129 | 			fs.mkdirSync(dirPath);
130 | 		}
131 | 	}
132 | 
133 | 	async rmdir(dirPath: string, recursive: boolean): Promise<void> {
134 | 		if (false) { // 此接口会出现无响应的 BUG
135 | 			await callAsyncApi(fs.rmdir, { dirPath, recursive });
136 | 		} else {
137 | 			fs.rmdirSync(dirPath, recursive);
138 | 		}
139 | 	}
140 | 
141 | 	async readdir(dirPath: string): Promise<string[]> {
142 | 		dirPath = dirPath.endsWith('/') ? dirPath : dirPath + '/';
143 | 		const ret = await callAsyncApi(fs.readdir, { dirPath });
144 | 		return ret.files;
145 | 	}
146 | 
147 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
148 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
149 | 	async readFile(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): Promise<string | ArrayBuffer> {
150 | 		const ret = await callAsyncApi(fs.readFile, { filePath, encoding: encoding === 'binary' ? undefined : encoding });
151 | 		return ret.data;
152 | 	}
153 | 
154 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
155 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
156 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8' | 'binary'): string | ArrayBuffer {
157 | 		return fs.readFileSync(filePath, encoding === 'binary' ? undefined : encoding);
158 | 	}
159 | 
160 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
161 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
162 | 	async writeFile(filePath: string, data: string | ArrayBuffer, encoding: string): Promise<void> {
163 | 		await callAsyncApi(fs.writeFile, { filePath, data, encoding: encoding as 'utf8' });
164 | 	}
165 | 	writeFileSync(filePath: string, data: ArrayBuffer, encoding: 'binary'): void;
166 | 	writeFileSync(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): void;
167 | 	writeFileSync(filePath: string, data: string | ArrayBuffer, encoding: string): void {
168 | 		return fs.writeFileSync(filePath, data, encoding as 'utf8');
169 | 	}
170 | 
171 | 	async copyFile(srcPath: string, destPath: string): Promise<void> {
172 | 		await callAsyncApi(fs.copyFile, { srcPath, destPath });
173 | 	}
174 | }
175 | 
176 | export class WechatInPackageFileSystem extends WechatFileSystem {
177 | 	readonly subpackages?: ISubPackage[] = [];
178 | 
179 | 	constructor(readonly root = '') {
180 | 		super(root);
181 | 		this.subpackages = config.subpackages || [];
182 | 	}
183 | 
184 | 	exists(filePath: string): Promise<boolean> {
185 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
186 | 		if (config.assets.files[filePath]) {
187 | 			return Promise.resolve(true);
188 | 		}
189 | 		return super.exists(filePath);
190 | 	}
191 | 
192 | 	existsSync(filePath: string): boolean {
193 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
194 | 		if (config.assets.files[filePath]) {
195 | 			return true;
196 | 		}
197 | 		return super.existsSync(filePath);
198 | 	}
199 | 
200 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
201 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
202 | 	async readFile(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): Promise<string | ArrayBuffer> {
203 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
204 | 		await this.loadSubpackage(filePath);
205 | 		return super.readFile(filePath, encoding as 'utf8');
206 | 	}
207 | 
208 | 	protected async loadSubpackage(filePath: string) {
209 | 		return new Promise<void>((resolve, reject) => {
210 | 			if (filePath[0] === '/') filePath = filePath.substring(1);
211 | 			const pkg = (this.subpackages || []).find(p => filePath.startsWith(p.root));
212 | 			if (pkg) {
213 | 				const loader = new SubPackageLoader(pkg);
214 | 				loader.verbose = config.verbose;
215 | 				const clear = () => loader.dispose();
216 | 				loader.event.once('done', () => {
217 | 					clear();
218 | 					resolve();
219 | 				});
220 | 				loader.event.once('failed', (err) => {
221 | 					clear();
222 | 					reject(err);
223 | 				});
224 | 				loader.start();
225 | 			} else {
226 | 				resolve();
227 | 			}
228 | 		});
229 | 	}
230 | 
231 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
232 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
233 | 	readFileSync(filePath: string, encoding: 'binary' | 'utf8' | 'utf-8'): string | ArrayBuffer {
234 | 		if (filePath[0] !== '/') filePath = path.join(this.root, filePath);
235 | 		return super.readFileSync(filePath, encoding as 'utf8');
236 | 	}
237 | }
238 | 


--------------------------------------------------------------------------------
/src/framework/tiny/utils/fs/fs.sizelimited.ts:
--------------------------------------------------------------------------------
  1 | import { filesize } from 'filesize';
  2 | import { path } from '../path';
  3 | import { avoidRepeat } from '../promise';
  4 | import FileUtils from './FileUtils';
  5 | import { deferred } from '../deferred';
  6 | 
  7 | interface IFileSystemSizeLimiterOptions {
  8 | 	/** 最大占用空间 */
  9 | 	readonly maxSize: number;
 10 | 	/** 存储目录 */
 11 | 	readonly root: string;
 12 | 	/** meta 文件名 */
 13 | 	readonly metaFile: string;
 14 | 	/**
 15 | 	 * 强制保留的文件
 16 | 	 *
 17 | 	 * NOTE: **注意，仅支持 root 目录下的内容，不支持其子目录的文件**
 18 | 	 */
 19 | 	retainFiles?: string[];
 20 | 	/** 保留的空间大小 */
 21 | 	reservedSize?: number;
 22 | 	readonly storage: LocalStorage;
 23 | 	readonly verbose?: boolean;
 24 | }
 25 | 
 26 | interface IFileMeta {
 27 | 	accessTime: number;
 28 | 	size: number;
 29 | }
 30 | 
 31 | const RESERVED_ID = 'protected.fs.reserved';
 32 | 
 33 | export class SizeLimitedFileSystem implements IFilesSystem {
 34 | 
 35 | 	private readonly version = '20240922';
 36 | 
 37 | 	log(...msg: any[]) {
 38 | 		this.options.verbose && console.log('[fs.sizelimited]', ...msg);
 39 | 	}
 40 | 
 41 | 	readonly manifest: Record<string, IFileMeta> = {};
 42 | 	getUsedSize() {
 43 | 		let size = 0;
 44 | 		for (const m of Object.values(this.manifest)) {
 45 | 			size += m.size;
 46 | 		}
 47 | 		return size;
 48 | 	}
 49 | 
 50 | 	constructor(readonly fs: IFilesSystem, readonly options: IFileSystemSizeLimiterOptions) {
 51 | 		this.options.retainFiles = this.options.retainFiles || [];
 52 | 		this.options.retainFiles.push(RESERVED_ID);
 53 | 		this.options.retainFiles.push(this.options.metaFile);
 54 | 		const reservedSize = (options.reservedSize || 0) + 1024 * 1000;
 55 | 		this.options.reservedSize = reservedSize;
 56 | 		this.log(`文件系统概况: 容量${filesize(options.maxSize)} 保留${filesize(reservedSize || 0)}`);
 57 | 	}
 58 | 
 59 | 	private async initialize() {
 60 | 		if (this.$initialized) return Promise.resolve();
 61 | 		return avoidRepeat('fs.size-limited.initialize', async () => {
 62 | 			const dir = path.dirname(this.options.metaFile);
 63 | 			await this.fs.mkdir(dir, true);
 64 | 			if (await this.fs.exists(this.options.metaFile) && (await this.fs.stat(this.options.metaFile)).isFile()) {
 65 | 				const text = await this.fs.readFile(this.options.metaFile, 'utf8');
 66 | 				(this.manifest as Record<string, IFileMeta>) = JSON.parse(text) as Record<string, IFileMeta>;
 67 | 			}
 68 | 
 69 | 			const VERSION = 'fs.sizelimited.version';
 70 | 			const version = this.options.storage.getItem(VERSION);
 71 | 			if (version != this.version) {
 72 | 				try {
 73 | 					this.log('文件系统版本升级,即将清空磁盘数据', version, '->', this.version);
 74 | 					await this.doClearRoot();
 75 | 				} catch (error) {
 76 | 					this.log('文件系统版本升级失败', error);
 77 | 				}
 78 | 			}
 79 | 			this.initReserved();
 80 | 			this.$initialized = true;
 81 | 			this.options.storage.setItem(VERSION, this.version);
 82 | 			this.log(`文件系统概况: 可用容量${filesize(this.options.maxSize - this.getUsedSize())}`);
 83 | 		});
 84 | 	}
 85 | 	private $initialized = false;
 86 | 
 87 | 	async unlink(filePath: string): Promise<void> {
 88 | 		await this.initialize();
 89 | 		this.updateMeta(filePath, undefined);
 90 | 		if (await this.fs.exists(filePath)) {
 91 | 			this.log('删除文件', filePath);
 92 | 			await this.fs.unlink(filePath);
 93 | 		}
 94 | 	}
 95 | 
 96 | 	async rename(oldPath: string, newPath: string): Promise<void> {
 97 | 		await this.initialize();
 98 | 		this.updateMeta(newPath, this.manifest[newPath]);
 99 | 		this.updateMeta(oldPath, undefined);
100 | 		await this.fs.rename(oldPath, newPath);
101 | 	}
102 | 
103 | 	mkdir(dirPath: string, recursive: boolean): Promise<void> {
104 | 		return this.fs.mkdir(dirPath, recursive);
105 | 	}
106 | 
107 | 	async copyFile(src: string, dist: string): Promise<void> {
108 | 		const data = await this.fs.readFile(src, 'binary');
109 | 		await this.writeFile(dist, data, 'binary');
110 | 	}
111 | 
112 | 	async rmdir(dirPath: string, recursive: boolean): Promise<void> {
113 | 		await this.initialize();
114 | 		const files = await FileUtils.getFiles(this.fs, dirPath, recursive);
115 | 		files.forEach(f => this.updateMeta(f, undefined));
116 | 		await this.fs.rmdir(dirPath, recursive);
117 | 	}
118 | 
119 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
120 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
121 | 	async writeFile(filePath: any, data: any, encoding: any): Promise<void> {
122 | 		await this.initialize();
123 | 		const size = Math.max(this.getDataSize(data) - (this.manifest[filePath]?.size || 0), 0);
124 | 		if (size > (this.options.maxSize - this.options.reservedSize)) throw new Error('No enough space');
125 | 		let avaliable = this.options.maxSize - this.getUsedSize();
126 | 		if (avaliable < size) {
127 | 			let files: ({ path: string; } & IFileMeta)[] = [];
128 | 			for (const pair of Object.entries(this.manifest)) {
129 | 				files.push({ path: pair[0], ...(pair[1]) });
130 | 			}
131 | 			files.sort((a, b) => a.accessTime - b.accessTime);
132 | 			files = files.filter(f => {
133 | 				if (f.path == this.options.metaFile || f.path === RESERVED_ID) return false;
134 | 				if (this.options.retainFiles) {
135 | 					return !this.options.retainFiles.includes(f.path);
136 | 				}
137 | 				return true;
138 | 			});
139 | 
140 | 			const drop: typeof files = [];
141 | 			for (const f of files) {
142 | 				drop.push(f);
143 | 				avaliable += f.size;
144 | 				if (avaliable > size) break;
145 | 			}
146 | 			this.log('为了保存', filePath, '而删除', drop);
147 | 			for (const f of drop) {
148 | 				await this.unlink(f.path);
149 | 			}
150 | 		}
151 | 		this.updateMeta(filePath, { accessTime: Date.now(), size: this.getDataSize(data) });
152 | 		await this.fs.writeFile(filePath, data, encoding);
153 | 	}
154 | 
155 | 	exists(filePath: string): Promise<boolean> {
156 | 		return this.fs.exists(filePath);
157 | 	}
158 | 
159 | 	existsSync(filePath: string): boolean {
160 | 		return this.fs.existsSync(filePath);
161 | 	}
162 | 
163 | 	stat(filePath: string): Promise<Stat> {
164 | 		return this.fs.stat(filePath);
165 | 	}
166 | 	statSync(filePath: string): Stat {
167 | 		return this.fs.statSync(filePath);
168 | 	}
169 | 
170 | 	readdir(dirPath: string): Promise<string[]> {
171 | 		return this.fs.readdir(dirPath);
172 | 	}
173 | 
174 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
175 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
176 | 	async readFile(filePath: any, encoding: any): Promise<ArrayBuffer | string> {
177 | 		await this.initialize();
178 | 		const data = await this.fs.readFile(filePath, encoding);
179 | 		this.updateMeta(filePath, { accessTime: Date.now(), size: this.getDataSize(data) });
180 | 		return data;
181 | 	}
182 | 
183 | 	private getDataSize(data: string | ArrayBuffer) {
184 | 		let size: number = 0;
185 | 		if (data instanceof ArrayBuffer) size = data.byteLength;
186 | 		else if (typeof data === 'string') size = data.length * 4;
187 | 		return size;
188 | 	}
189 | 
190 | 	/** 更新文件信息，meta 传入 null 表示删除文件 */
191 | 	private updateMeta(file: string, meta: IFileMeta) {
192 | 		if (!file.startsWith(this.options.root)) return;
193 | 		this.manifest[file] = meta;
194 | 		if (!meta) delete this.manifest[file];
195 | 		const root = this.manifest[this.options.metaFile];
196 | 		if (root) root.accessTime = Date.now();
197 | 		deferred(()=> {
198 | 			this.fs.writeFile(this.options.metaFile, JSON.stringify(this.manifest, undefined, '\t'), 'utf8');
199 | 		}, 500, 2500, 'fs.size-limited.update.meta');
200 | 	}
201 | 
202 | 	async clear() {
203 | 		await this.initialize();
204 | 		this.$initialized = false;
205 | 		await avoidRepeat('fs.size-limited.initialize', this.doClearRoot.bind(this));
206 | 		this.$initialized = true;
207 | 	}
208 | 
209 | 	protected async doClearRoot() {
210 | 		const children = await this.fs.readdir(this.options.root);
211 | 		const tasks = children.map(async c => {
212 | 			const e = path.join(this.options.root, c);
213 | 			const stat = await this.fs.stat(e);
214 | 			if (stat.isDirectory()) {
215 | 				await this.fs.rmdir(e, true);
216 | 			} else {
217 | 				const file = path.join(this.options.root, c);
218 | 				if (this.options.retainFiles.includes(file)) {
219 | 					this.log('保留文件', file);
220 | 					return;
221 | 				}
222 | 				await this.fs.unlink(e);
223 | 			}
224 | 		});
225 | 		const rets = await Promise.allSettled(tasks);
226 | 		for (let i = 0; i < children.length; i++) {
227 | 			const ret = rets[i];
228 | 			if (ret.status === 'rejected') {
229 | 				this.log('移除', children[i], '失败:', ret.reason);
230 | 			} else {
231 | 				this.log('移除', children[i], '成功');
232 | 			}
233 | 		}
234 | 		(this.manifest as Record<string, IFileMeta>) = {};
235 | 		this.initReserved();
236 | 		await this.fs.writeFile(this.options.metaFile, JSON.stringify(this.manifest, undefined, '\t'), 'utf8');
237 | 	}
238 | 
239 | 	private initReserved() {
240 | 		this.manifest[this.options.metaFile] = { accessTime: Date.now(), size: 1024 * 1000 };
241 | 		this.manifest[RESERVED_ID] = { accessTime: Date.now(), size: this.options.reservedSize || 0 };
242 | 	}
243 | 
244 | 	getAvailableSize() {
245 | 		return filesize(this.options.maxSize - this.getUsedSize());
246 | 	}
247 | }
248 | 


--------------------------------------------------------------------------------
/src/framework/platform/dev/page/debug-panel.html:
--------------------------------------------------------------------------------
  1 | <style>
  2 |   .capsule-box {
  3 |     position: fixed;
  4 |     right: 3%;
  5 |     top: 5%;
  6 |     background: rgba(0, 0, 0, 0.16);
  7 |     color: #fff;
  8 |     border-radius: 1rem;
  9 |     border: 1rpx solid rgba(255, 255, 255, 0.25);
 10 |     z-index: 99;
 11 |     display: flex;
 12 |     justify-items: center;
 13 |     align-items: center;
 14 |     justify-content: space-around;
 15 |     box-shadow: 0 0 2px rgba(255, 255, 255, 0.6);
 16 |   }
 17 | 
 18 |   .capsule-box div {
 19 |     padding: 0.3rem;
 20 |     padding-bottom: 0.4rem;
 21 |   }
 22 | 
 23 |   .capsule-box div:hover {
 24 |     /* 设置边框样式 */
 25 |     color: #fff;
 26 |   }
 27 | 
 28 |   .capsule-ellipsis {
 29 |     vertical-align: middle;
 30 |     border-right: 0.1rem solid rgba(255, 255, 255, 0.2);
 31 |     padding-right: 0.5rem;
 32 |     padding-left: 0.5rem;
 33 |     width: 1.3rem;
 34 |   }
 35 | 
 36 |   .capsule-close {
 37 |     vertical-align: middle;
 38 |     margin-left: 0rem;
 39 |     margin-right: 0.5rem;
 40 |     width: 1.3rem;
 41 |   }
 42 | 
 43 | 
 44 |   #debug-panel-container {
 45 |     position: fixed;
 46 |     bottom: 0;
 47 |     left: 0;
 48 |     width: calc(100vw - 16px);
 49 |     margin: 0 8px;
 50 |     min-height: 220px;
 51 |     background-color: #ECECEC;
 52 |     border-radius: 8px 8px 0 0;
 53 |     /* 左上角和右上角都设置为20像素的圆角 */
 54 |     display: none;
 55 |     z-index: 1;
 56 |   }
 57 | 
 58 |   .cancel {
 59 |     position: absolute;
 60 |     bottom: 0%;
 61 |     text-align: center;
 62 |     width: 100%;
 63 |     height: 65px;
 64 |     background-color: #ffffff;
 65 |     display: flex;
 66 |     align-items: self-start;
 67 |     justify-content: center;
 68 |   }
 69 | 
 70 |   .cancel button {
 71 |     margin-top: 15px;
 72 |     font: initial;
 73 |     border: none;
 74 |     background-color: transparent;
 75 |     color: inherit;
 76 |     outline: none;
 77 |     font-size: 0.8rem;
 78 |     letter-spacing: 5px;
 79 |     font-weight: 800;
 80 |     color: #109DA6;
 81 |   }
 82 | 
 83 |   .header {
 84 |     display: flex;
 85 |     margin: 15px;
 86 |     margin-bottom: 2px;
 87 |     align-items: center;
 88 |   }
 89 | 
 90 |   .header img {
 91 |     width: 40px;
 92 |   }
 93 | 
 94 |   .header p {
 95 |     margin: 2px 0;
 96 |     font-size: 10px;
 97 | 
 98 |   }
 99 | 
100 |   .box {
101 |     margin: 5px;
102 |     margin-top: 10px;
103 |     text-align: center;
104 |     -webkit-user-select: none;
105 |     /* Safari */
106 |     -moz-user-select: none;
107 |     /* Firefox */
108 |     -ms-user-select: none;
109 |     /* Internet Explorer */
110 |     user-select: none;
111 |     /* Standard syntax */
112 |   }
113 | 
114 |   .box div {
115 |     width: 1rem;
116 |     height: 1rem;
117 |     padding: 15px;
118 |     background-color: #ffffff;
119 |     border-radius: 5px;
120 |     margin-bottom: 5px;
121 |   }
122 | 
123 |   .box img {
124 |     vertical-align: middle;
125 |     height: 100%;
126 |   }
127 | 
128 |   .box span {
129 |     color: #5B5B5B;
130 |     font-size: 0.6rem;
131 |   }
132 | 
133 |   .unselectable {
134 |     -webkit-user-select: none;
135 |     /* Safari */
136 |     -moz-user-select: none;
137 |     /* Firefox */
138 |     -ms-user-select: none;
139 |     /* Internet Explorer */
140 |     user-select: none;
141 |     /* Standard syntax */
142 |     -webkit-user-drag: none;
143 |     /* Safari */
144 |     -moz-user-drag: none;
145 |     /* Firefox */
146 |     -ms-user-drag: none;
147 |     /* Internet Explorer */
148 |     user-drag: none;
149 |     /* Standard syntax */
150 |   }
151 | </style>
152 | 
153 | 
154 | <div class="capsule-box unselectable">
155 |   <div class="unselectable">
156 |     <img
157 |       class="capsule-ellipsis"
158 |       id="capsule-open-debug-panel"
159 |       src="./tiny-tools/images/ellipsis.png"
160 |       alt=""
161 |       onclick="window.tinyWebDevTools.toggleDebugPanel()"
162 |     />
163 |   </div>
164 | 
165 |   <div class="unselectable">
166 |     <img
167 |       alt=""
168 |       class="capsule-close"
169 |       src="./tiny-tools/images/close.png"
170 |       onclick="getPlatform().exit()"
171 |     />
172 |   </div>
173 | </div>
174 | 
175 | <div id="debug-panel-container">
176 |   <div class="header unselectable">
177 |     <div style="margin-right: 10px;"> <img src="./icon.png" alt=""> </div>
178 |     <div>
179 |       <h5 id="debug-title-app-name" style="margin: 0px;"> 超级电玩城 </h5>
180 |       <p> <span id="debug-title-app-channel">dev</span> <span id="debug-title-app-version">1.0.0</span> </p>
181 |     </div>
182 |   </div>
183 | 
184 |   <div style="margin-left: 10px; display: flex; align-items: center;">
185 | 
186 |     <div class="box" onclick="getPlatform().share(tinysdk?.remoteConfigs?.share || {})">
187 |       <div>
188 |         <img src="./tiny-tools/images/share.png" alt="">
189 |       </div>
190 |       <span>分享应用</s>
191 |     </div>
192 | 
193 |     <div class="box" onclick="window.tinyWebDevTools.toggleSwitch('vConsole')">
194 |       <div>
195 |         <img src="./tiny-tools/images/debug.png" alt="">
196 |       </div>
197 |       <span>开发日志</s>
198 |     </div>
199 | 
200 |     <div class="box" onclick="window.tinyWebDevTools.toggleSwitch('performanceMonitor')">
201 |       <div> <img src="./tiny-tools/images/performance.png" alt=""></div>
202 |       <span>性能面板</s>
203 |     </div>
204 | 
205 |     <div class="box" onclick="getPlatform().reload()" >
206 |       <div>
207 |         <img src="./tiny-tools/images/reload.png" alt="">
208 |       </div>
209 |       <span>重启应用</s>
210 |     </div>
211 | 
212 |     <div class="box" onclick="window.tinyWebDevTools.toggleSwitch('navigator-line')">
213 |       <div>
214 |         <img src="./tiny-tools/images/phone.png" alt="" width="60%">
215 |       </div>
216 |       <span>屏幕模拟</s>
217 |     </div>
218 |   </div>
219 | 
220 |   <div class="cancel unselectable">
221 |     <button onclick="window.tinyWebDevTools.closeDebugPanel()">关闭</button>
222 |   </div>
223 | </div>
224 | 
225 | <script>
226 |   window.tinyWebDevTools = window.tinyWebDevTools || {};
227 |   const container = document.getElementById('debug-panel-container');
228 |   window.tinyWebDevTools.toggleDebugPanel = function () {
229 |     // 切换弹出页面的显示状态
230 |     if (container.style.display === 'block') {
231 |       container.style.display = 'none';
232 |       console.log(window);
233 |     } else {
234 |       container.style.display = 'block';
235 |     }
236 |   };
237 |   const openPanelButton = document.getElementById('capsule-open-debug-panel');
238 |   window.tinyWebDevTools.closeDebugPanel = function (event) {
239 |     container.style.display = 'none';
240 |   };
241 |   document.addEventListener('click', function() {
242 |     // 检查点击的目标元素是否位于弹出页面容器之外
243 |     if (!container.contains(event.target) && event.target !== openPanelButton) {
244 |       window.tinyWebDevTools.closeDebugPanel();
245 |     }
246 |   });
247 | 
248 |   const name = document.getElementById('debug-title-app-name');
249 |   const channel = document.getElementById('debug-title-app-channel');
250 |   const version = document.getElementById('debug-title-app-version');
251 | 
252 |   window.tinyWebDevTools.setAppInfo = function (config) {
253 |     name.innerText = config.name || 'tiny-game-kit';
254 |     channel.innerText = config.channel || 'dev';
255 |     version.innerText = config.version || '0.0.0';
256 |   }
257 |   config && window.tinyWebDevTools.setAppInfo(config);
258 | 
259 |   (function(){
260 |     function waitUtil(condition, timeout = 0, checkInterval = 0) {
261 |       return new Promise((resolve, reject) => {
262 |         let duration = 0;
263 |         const timerID = setInterval(() => {
264 |           if (!condition) {
265 |             clearInterval(timerID);
266 |             reject(new Error('Invalid condition'));
267 |           }
268 |           duration += checkInterval;
269 |           const ret = condition();
270 |           if (ret) {
271 |             clearInterval(timerID);
272 |             resolve(ret);
273 |           } else if (timeout && duration >= timeout) {
274 |             clearInterval(timerID);
275 |             reject(new Error('Time Out'));
276 |           }
277 |         }, Math.max(checkInterval || 0, 0));
278 |       });
279 |     }
280 |     function getSwitchValue(key) {
281 |       return localStorage.getItem('tinyWebDevTools:' + key) === 'true';
282 |     }
283 |     function setSwitchValue(key, value) {
284 |       localStorage.setItem('tinyWebDevTools:' + key, value == true);
285 |     }
286 |     function syncSwitch(key, value) {
287 |       getPlatform().emit('switchDebugOption', key, value);
288 |     }
289 |     window.tinyWebDevTools.toggleSwitch = function (key) {
290 |       const value = !getSwitchValue(key);
291 |       setSwitchValue(key, value);
292 |       syncSwitch(key, value);
293 |       window.tinyWebDevTools.closeDebugPanel();
294 |       return !value;
295 |     }
296 | 
297 |     waitUtil(()=> typeof game === 'object' && game.$startupStatus['application'] == 'setup').then(()=> {
298 |       window.tinyWebDevTools.setAppInfo({
299 |         name: game.options.name,
300 |         channel: getPlatform().channel,
301 |         version: `${game.options.application.version.name} (${game.options.application.version.code})`
302 |       });
303 |       syncSwitch('navigator-line', getSwitchValue('navigator-line'));
304 |       syncSwitch('vConsole', getSwitchValue('vConsole'));
305 |       setTimeout(()=> {
306 |         syncSwitch('performanceMonitor', getSwitchValue('performanceMonitor'));
307 |       }, 16 * 2);
308 |     });
309 |   })();
310 | </script>
311 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/fs.web.ts:
--------------------------------------------------------------------------------
  1 | import { path } from 'framework/tiny/utils/path';
  2 | import { avoidRepeat } from 'framework/tiny/utils/promise';
  3 | import localforage from 'localforage';
  4 | interface IPathEntry {
  5 | 	/** 文件字节大小，未必可靠，实现中如果平台不支持应返回`1` */
  6 | 	size: number;
  7 | 	/** 文件最后修改时间，未必可靠，实现中如果平台不支持应返回`0` */
  8 | 	lastModifiedTime: number;
  9 | 	/** 类型 */
 10 | 	type: 'file' | 'directory';
 11 | 	/** 子路径 */
 12 | 	children?: Set<string>;
 13 | }
 14 | 
 15 | type IPathEntrySerialized = Omit<IPathEntry, 'children'> & { children?: string[] };
 16 | 
 17 | export class WebIndexedDBFileSystem implements IFilesSystem {
 18 | 	readonly entries: Record<string, IPathEntry>;
 19 | 
 20 | 	readonly store: LocalForage;
 21 | 	constructor(readonly name: string, readonly root: string) {
 22 | 		this.store = localforage.createInstance({
 23 | 			name: config?.name || 'tiny',
 24 | 			storeName: name,
 25 | 			driver: localforage.INDEXEDDB
 26 | 		});
 27 | 	}
 28 | 
 29 | 	protected initialize() {
 30 | 		if (this.entries) return this.entries;
 31 | 		return avoidRepeat('fs.web.idfs.tiny.initialize', async () => {
 32 | 			let data = await this.store.getItem('__meta__') as Record<string, IPathEntrySerialized>;
 33 | 			const newDisk = !data;
 34 | 			if (newDisk) {
 35 | 				data = { [this.root]: { type: 'directory', size: 0, lastModifiedTime: Date.now(), children: [] } };
 36 | 			}
 37 | 			(this.entries as typeof this.entries) = {};
 38 | 			for (const [id, e] of Object.entries(data)) {
 39 | 				this.entries[id] = { ...e, children: e.children ? new Set(e.children) : undefined };
 40 | 			}
 41 | 			if (newDisk) this.saveMetaData();
 42 | 		});
 43 | 	}
 44 | 
 45 | 	protected saveMetaData() {
 46 | 		return avoidRepeat('fs.web.idfs.tiny.meta.save', async () => {
 47 | 			const data = {} as Record<string, IPathEntrySerialized>;
 48 | 			for (const [id, e] of Object.entries(this.entries)) {
 49 | 				const value = Object.assign({}, e as unknown as IPathEntrySerialized);
 50 | 				if (e.type === 'directory' && e.children) {
 51 | 					value.children = Array.from(e.children);
 52 | 				}
 53 | 				data[id] = value;
 54 | 			}
 55 | 			return this.store.setItem('__meta__', data);
 56 | 		});
 57 | 	}
 58 | 
 59 | 	private saveEntry(entryPath: string, entry: IPathEntry) {
 60 | 		this.entries[entryPath] = entry;
 61 | 		this.syncParent(entryPath, 'add');
 62 | 		return this.saveMetaData();
 63 | 	}
 64 | 
 65 | 	private async removeEntry(entryPath: string) {
 66 | 		delete this.entries[entryPath];
 67 | 		this.store.removeItem(entryPath);
 68 | 		this.syncParent(entryPath, 'remove');
 69 | 		return this.saveMetaData();
 70 | 	}
 71 | 
 72 | 	private syncParent(filePath: string, action: 'add' | 'remove') {
 73 | 		const dir = path.dirname(filePath);
 74 | 		if (!dir) return;
 75 | 		const entry = path.basename(filePath);
 76 | 		const parent = this.entries[dir];
 77 | 		if (action === 'add') {
 78 | 			parent.children.add(entry);
 79 | 		} else if (action === 'remove') {
 80 | 			parent.children.delete(entry);
 81 | 		}
 82 | 	}
 83 | 
 84 | 
 85 | 	async unlink(filePath: string): Promise<void> {
 86 | 		await this.initialize();
 87 | 		const stat = await this.stat(filePath);
 88 | 		if (stat.isFile()) {
 89 | 			await this.removeEntry(filePath);
 90 | 		} else {
 91 | 			throw new Error(`Cannot unlink ${filePath} is not a file`);
 92 | 		}
 93 | 	}
 94 | 
 95 | 	async rename(oldPath: string, newPath: string): Promise<void> {
 96 | 		await this.initialize();
 97 | 		const item: IPathEntry = this.entries[oldPath];
 98 | 		if (!item) throw new Error(`No such file or directory ${oldPath}`);
 99 | 		const dist = this.entries[newPath];
100 | 		if (dist) {
101 | 			if(dist.type !== item.type) throw new Error(`Cannot rename ${oldPath} to ${newPath}`);
102 | 			if (dist.type === 'directory') {
103 | 				await this.rmdir(newPath, true);
104 | 			} else {
105 | 				await this.unlink(newPath);
106 | 			}
107 | 			this.removeEntry(newPath);
108 | 		}
109 | 		await this.saveEntry(newPath, item);
110 | 	}
111 | 
112 | 	async mkdir(dirPath: string, recursive: boolean = false): Promise<void> {
113 | 		await this.initialize();
114 | 		if (recursive) {
115 | 			const dirs = [] as string[];
116 | 			let dir = dirPath;
117 | 			let exists = this.existsSync(dir);
118 | 			while (dir && !exists) {
119 | 				dirs.push(dir);
120 | 				dir = path.dirname(dir);
121 | 				exists = this.existsSync(dir);
122 | 			}
123 | 			dirs.reverse();
124 | 			for (const dir of dirs) {
125 | 				await this.mkdir(dir);
126 | 			}
127 | 		} else {
128 | 			const base = path.dirname(dirPath);
129 | 			if (base) {
130 | 				const be = this.entries[base] as IPathEntry;
131 | 				if (!be || be.type != 'directory') throw new Error(`Cannot make director at ${dirPath}`);
132 | 			}
133 | 			let e = this.entries[dirPath] as IPathEntry;
134 | 			if (!e) {
135 | 				e = {
136 | 					type: 'directory',
137 | 					size: 0,
138 | 					lastModifiedTime: Date.now(),
139 | 					children: new Set<string>(),
140 | 				};
141 | 			}
142 | 			await this.saveEntry(dirPath, e);
143 | 		}
144 | 	}
145 | 
146 | 	async rmdir(dirPath: string, recursive: boolean): Promise<void> {
147 | 		const dir = this.entries[dirPath];
148 | 		if (!dir || dir.type !== 'directory') {
149 | 			throw new Error(`Directory ${dir} does not exists exists`);
150 | 		}
151 | 		if (dir.children.size && !recursive) {
152 | 			throw new Error(`Directory ${dirPath} is not empty`);
153 | 		}
154 | 		for (const s of Array.from(dir.children)) {
155 | 			const f = path.join(dirPath, s);
156 | 			const se = this.entries[f];
157 | 			if (!se) continue;
158 | 			if (se.type === 'directory') {
159 | 				await this.rmdir(f, recursive);
160 | 			} else {
161 | 				await this.unlink(f);
162 | 			}
163 | 		}
164 | 		await this.removeEntry(dirPath);
165 | 	}
166 | 
167 | 	writeFile(filePath: string, data: ArrayBuffer, encoding: 'binary'): Promise<void>;
168 | 	writeFile(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): Promise<void>;
169 | 	async writeFile(filePath: any, data: any, encoding: any): Promise<void> {
170 | 		await this.initialize();
171 | 		let dir = path.dirname(filePath);
172 | 		while (dir && dir !== this.root) {
173 | 			const e = this.entries[dir] as IPathEntry;
174 | 			if (!e || e.type !== 'directory') {
175 | 				throw new Error(`Directory ${dir} does not exists`);
176 | 			}
177 | 			dir = path.dirname(dir);
178 | 		}
179 | 		let size = 0;
180 | 		if (typeof data === 'string') size = data.length;
181 | 		else if (data instanceof ArrayBuffer) size = data.byteLength;
182 | 		const e: IPathEntry = { size, type: 'file', lastModifiedTime: Date.now() };
183 | 		this.syncParent(filePath, 'add');
184 | 		await this.store.setItem(filePath, data);
185 | 		await this.saveEntry(filePath, e);
186 | 	}
187 | 
188 | 	writeFileSync(filePath: string, data: ArrayBuffer, encoding: 'binary'): void;
189 | 	writeFileSync(filePath: string, data: string, encoding: 'utf8' | 'utf-8'): void;
190 | 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
191 | 	writeFileSync(filePath: any, data: any, encoding: any): void {
192 | 		throw new Error('Method not implemented.');
193 | 	}
194 | 
195 | 	async exists(filePath: string): Promise<boolean> {
196 | 		if (filePath === '/') return true;
197 | 		if (filePath.endsWith('://')) return true;
198 | 		await this.initialize();
199 | 		return this.existsSync(filePath);
200 | 	}
201 | 
202 | 	existsSync(filePath: string): boolean {
203 | 		if (!this.entries) throw new Error('File system is not initialized');
204 | 		return this.entries[filePath] != null;
205 | 	}
206 | 
207 | 	async stat(filePath: string): Promise<Stat> {
208 | 		await this.initialize();
209 | 		return this.statSync(filePath);
210 | 	}
211 | 
212 | 	statSync(filePath: string): Stat {
213 | 		if (!this.entries) throw new Error('File system is not initialized');
214 | 		const e = this.entries[filePath];
215 | 		if (!e) throw new Error(`No such file or directory ${filePath}`);
216 | 		return {
217 | 			size: e.size,
218 | 			lastModifiedTime: e.lastModifiedTime,
219 | 			isFile: () => e.type === 'file',
220 | 			isDirectory: () => e.type === 'directory',
221 | 		};
222 | 	}
223 | 
224 | 	async readdir(dirPath: string): Promise<string[]> {
225 | 		await this.initialize();
226 | 		const item: IPathEntry = this.entries[dirPath];
227 | 		if (!item || item.type !== 'directory') throw new Error(`No such directory ${dirPath}`);
228 | 		return Array.from(item.children || []);
229 | 	}
230 | 
231 | 	readFile(filePath: string, encoding: 'binary'): Promise<ArrayBuffer>;
232 | 	readFile(filePath: string, encoding: 'utf8' | 'utf-8'): Promise<string>;
233 | 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
234 | 	async readFile(filePath: any, encoding: any): Promise<string | ArrayBuffer> {
235 | 		await this.initialize();
236 | 		const e = this.entries[filePath];
237 | 		if (!e) {
238 | 			throw new Error(`${filePath} does not exists`);
239 | 		} else if (e.type !== 'file') {
240 | 			throw new Error(`${filePath} is not a valid file`);
241 | 		}
242 | 		return this.store.getItem(filePath);
243 | 	}
244 | 
245 | 	readFileSync(filePath: string, encoding: 'binary'): ArrayBuffer;
246 | 	readFileSync(filePath: string, encoding: 'utf8' | 'utf-8'): string;
247 | 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
248 | 	readFileSync(filePath: any, encoding: any): string | ArrayBuffer {
249 | 		throw new Error('Method not implemented.');
250 | 	}
251 | 
252 | 	async copyFile(src: string, dist: string): Promise<void> {
253 | 		await this.initialize();
254 | 		const se = this.entries[src];
255 | 		if (!se || se.type !== 'file') throw new Error(`No such file ${src}`);
256 | 		const de = this.entries[dist];
257 | 		if (de && de.type === 'directory') throw new Error(`Cannot copy file to directory ${dist}`);
258 | 		await this.saveEntry(dist, se);
259 | 	}
260 | }
261 | 


--------------------------------------------------------------------------------
/src/framework/platform/web/platform.web.ts:
--------------------------------------------------------------------------------
  1 | import Bowser from 'bowser';
  2 | import { PlatformType } from 'framework/common/constants';
  3 | import { XHRHttp } from 'framework/tiny/utils/http.xhr';
  4 | import qrcode from 'qrcode-generator';
  5 | import qs from 'qs';
  6 | import Swal from 'sweetalert2';
  7 | import VConsole from 'vconsole';
  8 | import { DefinePlatfrom } from '../utils';
  9 | import { DefaultWebFont, WebCanvas } from './canvas';
 10 | import { BasicWebPlatform } from './platform.web.basic';
 11 | 
 12 | export class WebPlatform extends BasicWebPlatform implements Platform {
 13 | 
 14 | 	readonly Swal = Swal;
 15 | 
 16 | 	protected $http = new XHRHttp();
 17 | 	get channel(): string { return config.channel; }
 18 | 	get type(): string { return PlatformType.Web; }
 19 | 	get launchOptions() { return this.$launchOptions; }
 20 | 	protected $launchOptions = qs.parse(location.search, { ignoreQueryPrefix: true });
 21 | 
 22 | 	protected bowser = Bowser.getParser(window.navigator.userAgent);
 23 | 	readonly localStorage = window.localStorage;
 24 | 	readonly vconsole?: VConsole;
 25 | 	private deferredPrompt: {
 26 | 		prompt(): void;
 27 | 		userChoice: Promise<{ outcome: 'accepted' | 'dismissed'; }>;
 28 | 	};
 29 | 
 30 | 	constructor() {
 31 | 		super();
 32 | 		if (this.os.name == 'ios' || this.os.name == 'android') {
 33 | 			this.vconsole = new VConsole({ theme: 'dark', });
 34 | 			if (PRODUCTION) this.vconsole.hideSwitch();
 35 | 			this.on('switchDebugOption', (event, value) => {
 36 | 				if (event === 'vConsole') {
 37 | 					value ? this.vconsole.showSwitch() : this.vconsole.hideSwitch();
 38 | 				}
 39 | 			});
 40 | 		}
 41 | 		if (true) {
 42 | 			const KeyboardLocations: Record<number, TinyKeyboardEvent['location']> = {
 43 | 				[KeyboardEvent.DOM_KEY_LOCATION_LEFT]: 'left',
 44 | 				[KeyboardEvent.DOM_KEY_LOCATION_RIGHT]: 'right',
 45 | 				[KeyboardEvent.DOM_KEY_LOCATION_STANDARD]: 'standard',
 46 | 				[KeyboardEvent.DOM_KEY_LOCATION_NUMPAD]: 'numpad',
 47 | 			};
 48 | 			const convertKeyboardEvent = (ev: KeyboardEvent): TinyKeyboardEvent => {
 49 | 				return {
 50 | 					key: ev.key,
 51 | 					code: ev.keyCode,
 52 | 					location: KeyboardLocations[ev.location],
 53 | 					repeat: ev.repeat,
 54 | 					alt: ev.altKey,
 55 | 					ctrl: ev.ctrlKey,
 56 | 					meta: ev.metaKey,
 57 | 					shift: ev.shiftKey
 58 | 				};
 59 | 			};
 60 | 			document.addEventListener('keydown', ev => this.emit('keydown', convertKeyboardEvent(ev)));
 61 | 			document.addEventListener('keyup', ev => this.emit('keyup', convertKeyboardEvent(ev)));
 62 | 		}
 63 | 		// 获取安装提示，并显示安装按钮,如果没有该事件表示不支持PWA
 64 | 		window.addEventListener('beforeinstallprompt', (event) => {
 65 | 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 66 | 			this.deferredPrompt = event as any;
 67 | 		});
 68 | 		window.onload = () => {
 69 | 			const urlParams = new URLSearchParams(window.location.search);
 70 | 			const sourceParam = urlParams.get('scene');
 71 | 			// @ts-ignore 无法识别 navigator.standalone
 72 | 			if (navigator['standalone'] || window.matchMedia('(display-mode: standalone)').matches || sourceParam == 'pwa') {
 73 | 				this.$launchOptions = Object.assign(this.launchOptions || {}, { scene: 'pwa' });
 74 | 			}
 75 | 		};
 76 | 	}
 77 | 
 78 | 	check(type: keyof Platform): boolean {
 79 | 		switch (type) {
 80 | 			case 'checkShortcut':
 81 | 			case 'createShortcut':
 82 | 				return 'serviceWorker' in navigator;
 83 | 			default:
 84 | 				return super.check(type);
 85 | 		}
 86 | 	}
 87 | 
 88 | 	alert(message: string, title?: string): Promise<void> {
 89 | 		return new Promise((resolve, reject) => {
 90 | 			Swal.fire({ title: title || tr('提示'), text: message, confirmButtonText: tr('确定') }).finally(() => resolve());
 91 | 		});
 92 | 	}
 93 | 
 94 | 	accept(message: string, title?: string, confirm?: string, cancel?: string): Promise<void> {
 95 | 		return new Promise((resolve, reject) => {
 96 | 			Swal.fire({
 97 | 				title,
 98 | 				text: message,
 99 | 				showDenyButton: false,
100 | 				showCancelButton: true,
101 | 				confirmButtonText: confirm,
102 | 				denyButtonText: cancel,
103 | 				cancelButtonText: cancel
104 | 			}).then(result => {
105 | 				result.isConfirmed ? resolve() : reject(new Error(tr('操作被取消')));
106 | 			});
107 | 		});
108 | 	}
109 | 
110 | 	toast(message: string, icon?: ToastType): Promise<void> {
111 | 		try {
112 | 			Swal.fire({
113 | 				position: 'bottom',
114 | 				text: message,
115 | 				icon: icon === 'success' ? 'success' : icon === 'fail' ? 'error' : undefined,
116 | 				showConfirmButton: false,
117 | 				timer: 1500,
118 | 			});
119 | 			if (icon === 'loading') {
120 | 				Swal.showLoading(null);
121 | 			}
122 | 			return Promise.resolve();
123 | 		} catch (error) {
124 | 			return Promise.reject(error);
125 | 		}
126 | 	}
127 | 
128 | 	async showLoading(title: string): Promise<void> {
129 | 		Swal.fire({
130 | 			position: 'bottom',
131 | 			text: title,
132 | 			showConfirmButton: false,
133 | 			timer: 1500,
134 | 		});
135 | 		Swal.showLoading(null);
136 | 	}
137 | 
138 | 	async hideLoading(): Promise<void> {
139 | 		Swal.hideLoading();
140 | 	}
141 | 
142 | 
143 | 	async checkShortcut() {
144 | 		return this.deferredPrompt == null;
145 | 	}
146 | 
147 | 	async createShortcut() {
148 | 		this.deferredPrompt.prompt();
149 | 		const choiceResult = await this.deferredPrompt.userChoice;
150 | 		if (choiceResult.outcome !== 'accepted') {
151 | 			throw new Error(tr('操作被取消'));
152 | 		}
153 | 	}
154 | 
155 | 	async invite(params: ShareInfo): Promise<{ name?: string; icon?: string; }> {
156 | 		await this.share(params);
157 | 		return null;
158 | 	}
159 | 
160 | 	async share(params: ShareInfo) {
161 | 		const title = params.title ? tr(params.title) : tr('分享游戏');
162 | 		const text = params.desc ? tr(params.desc) : tr(`快来跟我一起玩{name}吧！`, { name: tr(config.name) });
163 | 		const query = params.query || {};
164 | 		const url = `${window.location.origin}${window.location.pathname}?${qs.stringify({ query })}`;
165 | 		const data: ShareData = { title, text, url };
166 | 		if (navigator && typeof navigator == 'object' && navigator.share) {
167 | 			await navigator.share(data);
168 | 		} else {
169 | 			try {
170 | 				const qr = qrcode(10, 'M');
171 | 				qr.addData(data.url);
172 | 				qr.make();
173 | 				const select = await Swal.fire({
174 | 					title: tr(data.title),
175 | 					html: `
176 | 					<div>
177 | 						<p>${tr(data.text)}</p>
178 | 						${qr.createImgTag(3, 6)}
179 | 					</div>
180 | 					<div style="display: flex; align-items: center; text-align: left;">
181 | 						<div class="input-group">
182 | 							<input type="text" value="${data.url}" readonly class="form-control"/>
183 | 							<button class="input-group-text clipboard-btn"><svg t="1719993917026" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="3518" width="28" height="28"><path d="M682.666667 341.333333h128v469.333334H341.333333v-128H213.333333V213.333333h469.333334v128z m0 85.333334v256h-256v42.666666h298.666666v-298.666666h-42.666666zM298.666667 298.666667v298.666666h298.666666V298.666667H298.666667z" fill="#8a8a8a" p-id="3519"></path></svg></button>
184 | 						</div>
185 | 					</div>
186 | 					<div class="swal2-validation-message" id="swal2-validation-message" style="display: none;"></div>
187 | 					`,
188 | 					didOpen: () => {
189 | 						document.querySelector('.clipboard-btn').addEventListener('click', async () => {
190 | 							try {
191 | 								await this.setClipboardData(data.url);
192 | 								const icon = '<svg t="1719998602102" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4765" width="28" height="28"><path d="M512 0C230.4 0 0 230.4 0 512s230.4 512 512 512 512-230.4 512-512S793.6 0 512 0z m0 947.2c-240.64 0-435.2-194.56-435.2-435.2S271.36 76.8 512 76.8s435.2 194.56 435.2 435.2-194.56 435.2-435.2 435.2z m266.24-578.56c0 10.24-5.12 20.48-10.24 25.6l-286.72 286.72c-5.12 5.12-15.36 10.24-25.6 10.24s-20.48-5.12-25.6-10.24l-163.84-163.84c-15.36-5.12-20.48-15.36-20.48-25.6 0-20.48 15.36-40.96 40.96-40.96 10.24 5.12 20.48 10.24 25.6 15.36l138.24 138.24 261.12-261.12c5.12-5.12 15.36-10.24 25.6-10.24 20.48-5.12 40.96 15.36 40.96 35.84z" fill="#6BC839" p-id="4766"></path></svg>';
193 | 								document.querySelector('.input-group-text').innerHTML = icon;
194 | 							} catch (error) {
195 | 								const tips: HTMLDivElement = document.querySelector('.swal2-validation-message');
196 | 								tips.innerHTML = tr('复制失败,请手动复制上方链接');
197 | 								tips.style.display = 'flex';
198 | 							}
199 | 						});
200 | 					},
201 | 					showDenyButton: false,
202 | 					showConfirmButton: true,
203 | 					confirmButtonText: tr('确认'),
204 | 				});
205 | 				if (select.isConfirmed) {
206 | 					await this.setClipboardData(`${tr(data.text)} ${data.url}`);
207 | 				} else {
208 | 					throw new Error(tr('操作被取消'));
209 | 				}
210 | 			} catch (error) {
211 | 				console.error(error);
212 | 				this.setClipboardData(data.url);
213 | 			}
214 | 		}
215 | 	}
216 | 
217 | 	async validateRuntime(params: VerifiedRuntimeInfo) {
218 | 		const hostname = location.hostname;
219 | 		if (!PRODUCTION) {
220 | 			const debugDomains = [
221 | 				/localhost/,
222 | 				/127\.0\.0\.1/,
223 | 				/192\.168\.\d+\.\d+/,
224 | 				/\w+\.tiny\.fun/,
225 | 				/\w+\.tinyfun\.studio/,
226 | 			];
227 | 			for (const domain of debugDomains) {
228 | 				if (hostname.match(domain)) {
229 | 					return true;
230 | 				}
231 | 			}
232 | 		}
233 | 		return (params.domain || []).includes(hostname) || hostname === 'localhost';
234 | 	}
235 | 
236 | 	/**
237 | 	 * 渲染文字到贴图，不支持换行
238 | 	 * 该函数主要用于渲染用户名称等不易使用游戏字体进行渲染的文字内容
239 | 	 */
240 | 	renderText(text: string, style: Partial<TextStyle>): Promise<ArrayBuffer> {
241 | 		return this.canvas.renderText(text, style);
242 | 	}
243 | 
244 | 	/** 加载图像内容 */
245 | 	loadImageBuffer(url: string): Promise<ArrayBuffer> {
246 | 		return this.canvas.loadImageBuffer(url);
247 | 	}
248 | 	protected canvas = new WebCanvas({ defaultFont: DefaultWebFont[this.os.name] });
249 | }
250 | 
251 | DefinePlatfrom(WebPlatform);
252 | 


--------------------------------------------------------------------------------
/src/framework/webapi/xhr/xhr.common.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | /* eslint-disable camelcase */
  3 | import { AddEventListenerOptions, Event, EventListenerOptions, EventTarget, ProgressEvent } from '../event';
  4 | import { IURL } from './url';
  5 | export type XMLHttpRequestResponseType = '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
  6 | export type XMLHttpRequestMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
  7 | export type BodyInit = string | ArrayBuffer;
  8 | 
  9 | export interface XMLHttpRequestEventTargetEventMap {
 10 | 	'abort': ProgressEvent<XMLHttpRequestEventTarget>;
 11 | 	'error': ProgressEvent<XMLHttpRequestEventTarget>;
 12 | 	'load': ProgressEvent<XMLHttpRequestEventTarget>;
 13 | 	'loadend': ProgressEvent<XMLHttpRequestEventTarget>;
 14 | 	'loadstart': ProgressEvent<XMLHttpRequestEventTarget>;
 15 | 	'progress': ProgressEvent<XMLHttpRequestEventTarget>;
 16 | 	'timeout': ProgressEvent<XMLHttpRequestEventTarget>;
 17 | }
 18 | 
 19 | export interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
 20 | 	'readystatechange': Event;
 21 | }
 22 | 
 23 | export class XMLHttpRequestEventTarget extends EventTarget {
 24 | 
 25 | 	onabort: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 26 | 	onerror: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 27 | 	onload: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 28 | 	onloadend: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 29 | 	onloadstart: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 30 | 	onprogress: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 31 | 	ontimeout: ((this: XMLHttpRequestBase, ev: ProgressEvent) => any) | null;
 32 | 
 33 | 	addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void {
 34 | 		super.addEventListener(type, listener, options);
 35 | 	}
 36 | 
 37 | 	removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(type: K, listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any, options?: boolean | EventListenerOptions): void {
 38 | 		super.addEventListener(type, listener, options);
 39 | 	}
 40 | }
 41 | 
 42 | export class XMLHttpRequestUpload extends XMLHttpRequestEventTarget { }
 43 | 
 44 | export enum XMLHttpRequestReadyState {
 45 | 	UNSENT,
 46 | 	OPENED,
 47 | 	HEADERS_RECEIVED,
 48 | 	LOADING,
 49 | 	DONE,
 50 | }
 51 | 
 52 | /** Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing. */
 53 | export class XMLHttpRequestBase extends XMLHttpRequestEventTarget {
 54 | 
 55 | 	onreadystatechange: ((this: XMLHttpRequestBase, ev: Event) => any) | null;
 56 | 
 57 | 	public get url(): Readonly<IURL> { return this.$url; }
 58 | 	protected $url: IURL;
 59 | 	protected $method: XMLHttpRequestMethod;
 60 | 	protected $requestHeaders: { [key: string]: string; } = {};
 61 | 	protected $connectionStartAt: number;
 62 | 
 63 | 	/**
 64 | 	 * Returns client's state.
 65 | 	 */
 66 | 	get readyState(): XMLHttpRequestReadyState { return this.$readyState; }
 67 | 	set readyState(value: XMLHttpRequestReadyState) {
 68 | 		if (value != this.$readyState) {
 69 | 			this.$readyState = value;
 70 | 			if (this.onreadystatechange) {
 71 | 				const event = new Event('readystatechange');
 72 | 				this.onreadystatechange.call(this, event);
 73 | 				this.dispatchEvent(event);
 74 | 			}
 75 | 		}
 76 | 	}
 77 | 
 78 | 	protected $readyState: XMLHttpRequestReadyState;
 79 | 
 80 | 	/**
 81 | 	 * Returns the response's body.
 82 | 	 */
 83 | 	get response(): any { return this.$response; }
 84 | 	protected $response: any;
 85 | 
 86 | 	/**
 87 | 	 * Returns the text response.
 88 | 	 *
 89 | 	 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "text".
 90 | 	 */
 91 | 	get responseText(): string | null { return null; }
 92 | 
 93 | 	/**
 94 | 	 * Returns the response type.
 95 | 	 *
 96 | 	 * Can be set to change the response type. Values are: the empty string (default), "arraybuffer", "blob", "document", "json", and "text".
 97 | 	 *
 98 | 	 * When set: setting to "document" is ignored if current global object is not a Window object.
 99 | 	 *
100 | 	 * When set: throws an "InvalidStateError" DOMException if state is loading or done.
101 | 	 *
102 | 	 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
103 | 	 */
104 | 	responseType: XMLHttpRequestResponseType;
105 | 	get responseURL(): string { return null; }
106 | 
107 | 	/**
108 | 	 * Returns the document response.
109 | 	 *
110 | 	 * Throws an "InvalidStateError" DOMException if responseType is not the empty string or "document".
111 | 	 */
112 | 	get responseXML(): string { return null; }
113 | 	get status(): number { return 0; }
114 | 	readonly statusText: string;
115 | 
116 | 	/**
117 | 	 * Can be set to a time in milliseconds. When set to a non-zero value will cause fetching to terminate after the given time has passed. When the time has passed, the request has not yet completed, and the synchronous flag is unset, a timeout event will then be dispatched, or a "TimeoutError" DOMException will be thrown otherwise (for the send() method).
118 | 	 *
119 | 	 * When set: throws an "InvalidAccessError" DOMException if the synchronous flag is set and current global object is a Window object.
120 | 	 */
121 | 	timeout: number;
122 | 
123 | 	/**
124 | 	 * Returns the associated XMLHttpRequestUpload object. It can be used to gather transmission information when data is transferred to a server.
125 | 	 */
126 | 	get upload(): XMLHttpRequestUpload { return this.$upload; }
127 | 	protected $upload: XMLHttpRequestUpload;
128 | 
129 | 	/**
130 | 	 * True when credentials are to be included in a cross-origin request. False when they are to be excluded in a cross-origin request and when cookies are to be ignored in its response. Initially false.
131 | 	 *
132 | 	 * When set: throws an "InvalidStateError" DOMException if state is not unsent or opened, or if the send() flag is set.
133 | 	 */
134 | 	withCredentials: boolean;
135 | 
136 | 	/**
137 | 	 * Cancels any network activity.
138 | 	 */
139 | 	abort(): void { }
140 | 
141 | 	getAllResponseHeaders(): string { return ''; }
142 | 
143 | 	getResponseHeader(name: string): string | null { return null; }
144 | 
145 | 	/**
146 | 	 * Sets the request method, request URL, and synchronous flag.
147 | 	 *
148 | 	 * Throws a "SyntaxError" DOMException if either method is not a valid HTTP method or url cannot be parsed.
149 | 	 *
150 | 	 * Throws a "SecurityError" DOMException if method is a case-insensitive match for `CONNECT`, `TRACE`, or `TRACK`.
151 | 	 *
152 | 	 * Throws an "InvalidAccessError" DOMException if async is false, current global object is a Window object, and the timeout attribute is not zero or the responseType attribute is not the empty string.
153 | 	 */
154 | 	open(method: XMLHttpRequestMethod, url: string, async?: boolean, username?: string | null, password?: string | null): void { }
155 | 
156 | 	/**
157 | 	 * Acts as if the `Content-Type` header value for response is mime. (It does not actually change the header though.)
158 | 	 *
159 | 	 * Throws an "InvalidStateError" DOMException if state is loading or done.
160 | 	 */
161 | 	overrideMimeType(mime: string): void {
162 | 		this.$overridedMime = mime;
163 | 	}
164 | 	protected $overridedMime: string;
165 | 
166 | 	/**
167 | 	 * Initiates the request. The body argument provides the request body, if any, and is ignored if the request method is GET or HEAD.
168 | 	 *
169 | 	 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
170 | 	 */
171 | 	send(body?: BodyInit | null): void { }
172 | 
173 | 	/**
174 | 	 * Combines a header in author request headers.
175 | 	 *
176 | 	 * Throws an "InvalidStateError" DOMException if either state is not opened or the send() flag is set.
177 | 	 *
178 | 	 * Throws a "SyntaxError" DOMException if name is not a header name or if value is not a header value.
179 | 	 */
180 | 	setRequestHeader(name: string, value: string): void {
181 | 		this.$requestHeaders[name.toLowerCase()] = value;
182 | 	}
183 | 
184 | 	addEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequestBase, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void {
185 | 		super.addEventListener(type as any, listener, options);
186 | 	}
187 | 
188 | 	removeEventListener<K extends keyof XMLHttpRequestEventMap>(type: K, listener: (this: XMLHttpRequestBase, ev: XMLHttpRequestEventMap[K]) => any, options?: boolean | EventListenerOptions): void {
189 | 		super.removeEventListener(type as any, listener, options);
190 | 	}
191 | 
192 | 
193 | 	private $pollTicker: number = -1;
194 | 	protected $start_poll() {
195 | 		this.$stop_poll();
196 | 		const tick = this.$tick.bind(this);
197 | 		const tickLoop = () => {
198 | 			this.$pollTicker = requestAnimationFrame(tickLoop);
199 | 			tick();
200 | 		};
201 | 		this.$pollTicker = requestAnimationFrame(tickLoop);
202 | 		tick();
203 | 	}
204 | 
205 | 	protected $stop_poll() {
206 | 		if (this.$pollTicker != -1) {
207 | 			cancelAnimationFrame(this.$pollTicker);
208 | 			this.$pollTicker = -1;
209 | 		}
210 | 	}
211 | 
212 | 	protected $get_progress(): ProgressEventInit {
213 | 		return {};
214 | 	}
215 | 
216 | 	protected $dispatch_event(type: keyof XMLHttpRequestEventTargetEventMap) {
217 | 		let event: Event = undefined;
218 | 		if (type === 'progress') {
219 | 			const evt = new ProgressEvent('progress', this.$get_progress());
220 | 			event = evt;
221 | 		} else {
222 | 			event = new Event(type);
223 | 		}
224 | 		switch (type) {
225 | 			case 'load':
226 | 				if (this.onload) this.onload.call(this, event);
227 | 				break;
228 | 			case 'loadend':
229 | 				if (this.onloadend) this.onloadend.call(this, event);
230 | 				break;
231 | 			case 'loadstart':
232 | 				if (this.onloadstart) this.onloadstart.call(this, event);
233 | 				break;
234 | 			case 'progress':
235 | 				if (this.onprogress) this.onprogress.call(this, event);
236 | 				break;
237 | 			case 'timeout':
238 | 				if (this.ontimeout) this.ontimeout.call(this, event);
239 | 				break;
240 | 			case 'abort':
241 | 				if (this.onabort) this.onabort.call(this, event);
242 | 				break;
243 | 			case 'error':
244 | 				if (this.onerror) this.onerror.call(this, event);
245 | 				break;
246 | 			default:
247 | 				break;
248 | 		}
249 | 		this.dispatchEvent(event);
250 | 	}
251 | 
252 | 	protected $tick() { }
253 | }
254 | 


--------------------------------------------------------------------------------
/src/framework/platform/kuaishou/platform.kuaishou.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable @typescript-eslint/no-explicit-any */
  2 | import { PlatformType } from 'framework/common/constants';
  3 | import { SizeLimitedFileSystem } from 'framework/tiny/utils/fs/fs.sizelimited';
  4 | import { XHRHttp } from 'framework/tiny/utils/http.xhr';
  5 | import { path } from 'framework/tiny/utils/path';
  6 | import { GamePlatformBase } from '../platform.common';
  7 | import { DefinePlatfrom } from '../utils';
  8 | import { KuaishouFileDownloader } from './downloader.kuaishou';
  9 | import { KuaishouFileSystem, KuaishouInPackageFileSystem } from './fs.kuaishou';
 10 | import { KuaishouGameRecorder } from './recorder.kuaishou';
 11 | import { KuaishouLocalStorage } from './storage.kuaishou';
 12 | import { KuaiShouWebSocket } from './websocket.kuaishou';
 13 | import { DefaultWebFont, WebCanvas } from '../web/canvas';
 14 | 
 15 | interface AsyncCallbackOptions<T = any> {
 16 | 	success?(ret: T): void;
 17 | 	fail?(err: { msg: string; code: number }): void;
 18 | 	complete?(): void;
 19 | }
 20 | /** 调用微信的异步API */
 21 | function callAsyncApi<T, R>(api: (options: AsyncCallbackOptions<R> & T) => void, options?: T): Promise<R> {
 22 | 	return new Promise((resolve, reject) => {
 23 | 		const params: AsyncCallbackOptions = {
 24 | 			success: (ret: R) => resolve(ret),
 25 | 			fail: (err: { code: number, msg: string; }) => reject(new Error(`${err.code} ${err.msg}`)),
 26 | 			...options
 27 | 		};
 28 | 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 29 | 		api.call(ks, params as any);
 30 | 	});
 31 | }
 32 | 
 33 | export class KuaiShouPlatform extends GamePlatformBase implements Platform {
 34 | 
 35 | 	get type(): string { return PlatformType.KuaiShou; }
 36 | 	readonly systemInfo = ks.getSystemInfoSync();
 37 | 	readonly $launchOptions = ks.getLaunchOptionsSync();
 38 | 	protected $http = new XHRHttp();
 39 | 	get launchOptions() { return this.$launchOptions; }
 40 | 	get persistentDataPath() { return ks.env.USER_DATA_PATH; }
 41 | 
 42 | 	readonly localStorage = new KuaishouLocalStorage();
 43 | 
 44 | 	private _shareParams: {
 45 | 		title?: string;
 46 | 		imageUrl?: string;
 47 | 		query?: string;
 48 | 		imageUrlId?: string;
 49 | 	};
 50 | 
 51 | 	public get shareParams() {
 52 | 		return this._shareParams;
 53 | 	}
 54 | 	public set shareParams(v) {
 55 | 		this._shareParams = v;
 56 | 	}
 57 | 
 58 | 	now() { return Date.now() - this.$startAt; }
 59 | 	$startAt = Date.now();
 60 | 
 61 | 	constructor() {
 62 | 		super();
 63 | 
 64 | 		ks.onShow(() => {
 65 | 			this.emit('visible');
 66 | 			setTimeout(() => { this.emit('focus'); }, 32); // 微信 iOS 不按套路来
 67 | 		});
 68 | 
 69 | 		ks.onHide(() => {
 70 | 			this.emit('infocus');
 71 | 			this.emit('hidden');
 72 | 		});
 73 | 	}
 74 | 
 75 | 	get os(): OSInformation {
 76 | 		return {
 77 | 			name: this.systemInfo.platform.toLowerCase() as OSType,
 78 | 			version: this.systemInfo.system
 79 | 		};
 80 | 	}
 81 | 	get device(): DeviceInformation {
 82 | 		return {
 83 | 			model: this.systemInfo.model,
 84 | 			brand: this.systemInfo.brand,
 85 | 			language: (this.systemInfo.language || 'zh_CN').replace(/_/g, '-'),
 86 | 			screen: {
 87 | 				width: this.systemInfo.screenWidth,
 88 | 				height: this.systemInfo.screenHeight,
 89 | 				pixelRatio: this.systemInfo.pixelRatio,
 90 | 				dpi: 160,
 91 | 			},
 92 | 			window: {
 93 | 				width: this.systemInfo.windowWidth,
 94 | 				height: this.systemInfo.windowHeight,
 95 | 				safeArea: this.systemInfo.safeArea
 96 | 			}
 97 | 		};
 98 | 	}
 99 | 
100 | 	get application(): HostApplicationInformation {
101 | 		return {
102 | 			name: 'wechat',
103 | 			version: this.systemInfo.version,
104 | 			SDKVersion: this.systemInfo.SDKVersion
105 | 		};
106 | 	}
107 | 
108 | 	check(type: keyof Platform): boolean {
109 | 		switch (type) {
110 | 			case 'createShortcut':
111 | 			case 'checkShortcut':
112 | 				return this.os.name === 'android' && false; // 快手需要申请权限？
113 | 			case 'followProfile':
114 | 				return false;
115 | 			case 'loadImageBuffer':
116 | 				return this.os.name === 'ios'; // 安卓上还不验证域名
117 | 			case 'renderText':
118 | 				return this.os.name === 'ios'; // 安卓上文字渲染效果不好
119 | 			default:
120 | 				break;
121 | 		}
122 | 		return super.check(type);
123 | 	}
124 | 
125 | 	alert(message: string, title?: string): Promise<void> {
126 | 		return new Promise((resolve, reject) => {
127 | 			ks.showModal({
128 | 				title,
129 | 				content: message,
130 | 				showCancel: false,
131 | 				complete: ret => resolve()
132 | 			});
133 | 		});
134 | 	}
135 | 
136 | 	accept(message: string, title?: string, confirm?: string, cancel?: string): Promise<void> {
137 | 		return new Promise((resolve, reject) => {
138 | 			ks.showModal({
139 | 				title,
140 | 				content: message,
141 | 				confirmText: confirm,
142 | 				cancelText: cancel,
143 | 				showCancel: true,
144 | 				complete: (ret) => ret.confirm ? resolve() : reject()
145 | 			});
146 | 		});
147 | 	}
148 | 
149 | 	async toast(message: string, icon: 'success' | 'fail' | 'loading' | 'none' = 'none'): Promise<void> {
150 | 		if (icon === 'fail') {
151 | 			icon = 'error' as any;
152 | 		}
153 | 		await callAsyncApi(ks.showToast, { title: message, icon: icon as 'none' });
154 | 	}
155 | 
156 | 	vibrate(durationMs: number): void {
157 | 		if (durationMs >= 400) {
158 | 			ks.vibrateLong();
159 | 		} else {
160 | 			ks.vibrateShort();
161 | 		}
162 | 	}
163 | 
164 | 	async exit() {
165 | 		await callAsyncApi(ks.exitMiniProgram, {});
166 | 	}
167 | 
168 | 	share(params?: any): Promise<void> {
169 | 		if (params && !this.shareParams) this.shareParams = params;
170 | 		return new Promise((resolve, reject) => {
171 | 			ks.shareAppMessage({
172 | 				...params,
173 | 				success: resolve,
174 | 				fail: reject
175 | 			});
176 | 		});
177 | 	}
178 | 
179 | 	async invite(params: ShareInfo): Promise<{ name?: string; icon?: string; }> {
180 | 		await this.share({ ...params });
181 | 		return null;
182 | 	}
183 | 
184 | 	/** 登录 */
185 | 	async login() {
186 | 		const data = await callAsyncApi(ks.login);
187 | 		return {
188 | 			token: data.gameToken,
189 | 			openid: data.gameUserId,
190 | 		};
191 | 	}
192 | 
193 | 	/**
194 | 	 *	获取用户信息
195 | 	 * @returns IUserInfo 用户信息
196 | 	 */
197 | 	async getUserInfo(): Promise<IUserInfo> {
198 | 		if (this.$userInfo) return this.$userInfo;
199 | 		await this.authorize();
200 | 		const ret = await callAsyncApi(ks.getUserInfo);
201 | 		this.$userInfo = {
202 | 			nickName: ret.userName,
203 | 			avatarUrl: ret.userHead,
204 | 			gender: ret.gender ? (ret.gender === 'M' ? 1 : 2) : 0,
205 | 			language: undefined,
206 | 			city: ret.userCity || undefined
207 | 		};
208 | 		return this.$userInfo;
209 | 	}
210 | 	private $userInfo: IUserInfo;
211 | 
212 | 	/** 授权 */
213 | 	async authorize(scope: string = 'scope.userInfo') {
214 | 		let authorized = false;
215 | 		try {
216 | 			const settings = await callAsyncApi(ks.getSetting);
217 | 			// @ts-expect-error
218 | 			if (!settings || !settings.result || !settings.result[scope]) {
219 | 				throw new Error('not authorized');
220 | 			} else {
221 | 				authorized = true;
222 | 			}
223 | 		} catch (error) {
224 | 			authorized = false;
225 | 		}
226 | 		if (!authorized) {
227 | 			await callAsyncApi(ks.authorize, { scope });
228 | 		}
229 | 	}
230 | 
231 | 	createShortcut(): Promise<void> {
232 | 		return new Promise((resolve, reject) => {
233 | 			ks.saveAPKShortcut(ret => {
234 | 				if (ret.code === 1) {
235 | 					resolve();
236 | 				} else {
237 | 					reject(new Error(`创建失败: (${ret.code}) ${ret.msg}`));
238 | 				}
239 | 			});
240 | 
241 | 		});
242 | 	}
243 | 
244 | 	checkShortcut(): Promise<boolean> {
245 | 		return new Promise((resolve, reject) => {
246 | 			ks.getAPKShortcutInstallStatus(ret => {
247 | 				if (ret.code === 1) {
248 | 					resolve(ret.installed);
249 | 				} else {
250 | 					reject(new Error(`检查失败: (${ret.code}) ${ret.msg}`));
251 | 				}
252 | 			});
253 | 		});
254 | 	}
255 | 
256 | 	checkFollowProfile() {
257 | 		return new Promise<boolean>((resolve, reject) => {
258 | 			ks.checkFollowState({
259 | 				accountType: 'MiniGameOfficialAccount',
260 | 				callback: ret => {
261 | 					if (ret.errorCode === 1) {
262 | 						resolve(ret.hasFollow);
263 | 					} else {
264 | 						reject(new Error(`检查失败： (${ret.errorCode}) ${ret.errorMsg}`));
265 | 					}
266 | 				}
267 | 			});
268 | 		});
269 | 	}
270 | 
271 | 	followProfile() {
272 | 		return new Promise<void>((resolve, reject) => {
273 | 			ks.openUserProfile({
274 | 				accountType: 'MiniGameOfficialAccount',
275 | 				callback: async ret => {
276 | 					if (ret.errorCode === 1) {
277 | 						const followed = await this.checkFollowProfile();
278 | 						if (followed) {
279 | 							resolve();
280 | 						} else {
281 | 							reject(new Error('关注操作被取消'));
282 | 						}
283 | 					} else {
284 | 						reject(new Error(`检查失败： (${ret.errorCode}) ${ret.errorMsg}`));
285 | 					}
286 | 				}
287 | 			});
288 | 		});
289 | 	}
290 | 
291 | 	async showLoading(title: string): Promise<void> {
292 | 		await callAsyncApi(ks.showLoading, { title });
293 | 	}
294 | 
295 | 	async hideLoading(): Promise<void> {
296 | 		await callAsyncApi(ks.hideLoading);
297 | 	}
298 | 
299 | 	get fs() {
300 | 		if (!this.$fs) {
301 | 			this.$fs = {
302 | 				readonly: this.wrapReadonlyFS(new KuaishouInPackageFileSystem('StreamingAssets')),
303 | 				writable: new SizeLimitedFileSystem(new KuaishouFileSystem('fs.writable'), {
304 | 					verbose: !PRODUCTION,
305 | 					maxSize: 200 * 1000 * 1000,
306 | 					reservedSize: 16 * 1000 * 1000,
307 | 					storage: this.localStorage,
308 | 					root: this.persistentDataPath,
309 | 					retainFiles: [
310 | 						path.join(this.persistentDataPath, 'tinysdk.localStorage.bin'),
311 | 					],
312 | 					metaFile: path.join(this.persistentDataPath, 'fs.writable.json')
313 | 				})
314 | 			};
315 | 		}
316 | 		return this.$fs;
317 | 	}
318 | 	private $fs: { readonly?: IReadonlyFilesSystem; writable?: IFilesSystem; };
319 | 
320 | 	get downloader() {
321 | 		if (!this.$downloader) {
322 | 			this.$downloader = new KuaishouFileDownloader(this.fs.writable);
323 | 		}
324 | 		return this.$downloader;
325 | 	}
326 | 	private $downloader: IFileDownloader;
327 | 
328 | 	readonly recorder = new KuaishouGameRecorder();
329 | 	readonly WebSocket = KuaiShouWebSocket;
330 | 
331 | 	renderText(text: string, style: Partial<TextStyle>): Promise<ArrayBuffer> {
332 | 		return this.canvas.renderText(text, style);
333 | 	}
334 | 
335 | 	loadImageBuffer(url: string): Promise<ArrayBuffer> {
336 | 		return this.canvas.loadImageBuffer(url);
337 | 	}
338 | 	protected canvas = new KSCanvas({ defaultFont: DefaultWebFont[this.os.name] });
339 | 	readonly keyboard = new KSInputKeyboard();
340 | 
341 | 
342 | 	async validateRuntime(params: VerifiedRuntimeInfo) {
343 | 		return (params.appid || []).includes(this.systemInfo.host.appId);
344 | 	}
345 | }
346 | DefinePlatfrom(KuaiShouPlatform);
347 | 
348 | class KSCanvas extends WebCanvas {
349 | 	createCanvas(): HTMLCanvasElement {
350 | 		return wx.createCanvas() as unknown as HTMLCanvasElement;
351 | 	}
352 | 
353 | 	createImage(): HTMLImageElement {
354 | 		return wx.createImage() as unknown as HTMLImageElement;
355 | 	}
356 | }
357 | 
358 | class KSInputKeyboard implements InputKeyboard {
359 | 	visible: boolean;
360 | 	height?: number;
361 | 	value: string;
362 | 
363 | 	constructor() {
364 | 		wx.onKeyboardInput(({ value }) => this.value = value);
365 | 		wx.onKeyboardComplete(() => this.visible = false);
366 | 	}
367 | 
368 | 	show(params: ShowInputKeyboardParams): void {
369 | 		this.visible = true;
370 | 		this.value = params.text;
371 | 		wx.showKeyboard({
372 | 			defaultValue: params.text,
373 | 			confirmType: params.confirmType || 'done',
374 | 			confirmHold: params.confirmHold || true,
375 | 			maxLength: params.maxLength || (params.multiline ? 2048 : 256),
376 | 			multiple: params.multiline || false,
377 | 			success: () => this.visible = true,
378 | 			fail: () => this.visible = false
379 | 		});
380 | 	}
381 | 
382 | 	hide(): void {
383 | 		wx.hideKeyboard({ success: () => this.visible = false });
384 | 	}
385 | }
386 | 


--------------------------------------------------------------------------------