tmui-cli 2.0.2 → 2.0.4

package/data/uni-app-x-docs/uts/operator.md

@@ -0,0 +1,304 @@
+# 操作符@operator
+
+## 赋值运算符(Assignment operators)@Assignment-operators
+
+| 名字                                              | 简写的操作符 | 含义        |
+| ------------------------------------------------- | ------------ | ----------- |
+| 赋值(Assignment)                                  | x = y        | x = y       |
+| 加法赋值(Addition assignment)                     | x += y       | x = x + y   |
+| 减法赋值(Subtraction assignment)                  | x -= y       | x = x - y   |
+| 乘法赋值(Multiplication assignment)               | x \*= y      | x = x \* y  |
+| 除法赋值(Division assignment)                     | x /= y       | x = x / y   |
+| 求余赋值(Remainder assignment)                    | x %= y       | x = x % y   |
+| 左移位赋值(Left shift assignment)                 | x <<= y      | x = x << y  |
+| 右移位赋值(Right shift assignment)                | x >>= y      | x = x >> y  |
+| 无符号右移位赋值(Unsigned right shift assignment) | x >>>= y     | x = x >>> y |
+| 按位与赋值(Bitwise AND assignment)                | x &= y       | x = x & y   |
+| 按位异或赋值(Bitwise XOR assignment)              | x ^= y       | x = x ^ y   |
+| 按位或赋值(Bitwise OR assignment)                 | x \|= y      | x = x \| y    |
+
+## 比较运算符(comparison operators)@Comparison-operators
+
+| 运算符                              | 描述                                        | 返回 true 的示例 |
+| ----------------------------------- | ------------------------------------------- | ---------------- |
+| 等于 Equal (==)                     | 如果两边操作数相等时返回 true。             | var1==var2       |
+| 不等于 Not equal (!=)               | 如果两边操作数不相等时返回 true             | var1!=var2       |
+| 引用相等 Reference equal (===)      | 比较对象类型时，两边操作数指向同一个对象返回 true。比较基础类型时各平台有差异，[详情](#completecomparison)。 | var1===var2      |
+| 引用不等 Reference not equal (!==)  | 比较对象类型时，两边操作数不指向同一个对象时返回 true。比较基础类型时各平台有差异，[详情](#completecomparison)。 | var1!==var2      |
+| 大于 Greater than (>)               | 左边的操作数大于右边的操作数返回 true       | var1>var2        |
+| 大于等于 Greater than or equal (>=) | 左边的操作数大于或等于右边的操作数返回 true | var1>=var2       |
+| 小于 Less than (<)                  | 左边的操作数小于右边的操作数返回 true       | var1<var2        |
+| 小于等于 Less than or equal (<=)    | 左边的操作数小于或等于右边的操作数返回 true | var1<=var2       |
+
+## 算数运算符(Arithmetic operators)@Arithmetic-operators
+
+| 运算符   | 范例 | 描述                                                                                                                                     |
+| -------- | ---- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| 求余(%)  |      | 二元运算符. 返回相除之后的余数.                                                                                                          |
+| 自增(++) |      | 一元运算符. 将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值,然后再将操作数加一. |
+| 自减(--) |      | 一元运算符. 将操作数的值减一. 前后缀两种用法的返回值类似自增运算符.
+| 加(+)  |      | 二元运算符. 将两个数相加.                                                                                                          |
+| 减(-) |      | 二元运算符. 将两个数相减. |
+| 乘(*) |      | 二元运算符. 将两个数相乘.                                                                    |
+| 除(/) |      | 二元运算符. 将两个数相除.                                                                    |
+
+## 位运算符(Bitwise operators)@Bitwise-operators
+
+| Operator                        | Usage   | Description                                                                                                      |
+| ------------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------- |
+| 按位与 AND                      | a & b   | 在 a,b 的位表示中，每一个对应的位都为 1 则返回 1， 否则返回 0.                                                   |
+| 按位或 OR                       | a \| b  | 在 a,b 的位表示中，每一个对应的位，只要有一个为 1 则返回 1， 否则返回 0.                                         |
+| 按位异或 XOR                    | a ^ b   | 在 a,b 的位表示中，每一个对应的位，两个不相同则返回 1，相同则返回 0.                                             |
+| 按位非 NOT                      | ~ a     | 反转被操作数的位。                                                                                               |
+| 左移 shift                      | a << b  | 将 a 的二进制串向左移动 b 位,右边移入 0.                                                                         |
+| 算术右移                        | a >> b  | 把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位.(译注:算术右移左边空出的位是根据最高位是 0 和 1 来进行填充的) |
+| 无符号右移(左边空出位用 0 填充) | a >>> b | 把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位，并把左边空出的位都填充为 0                                   |
+
+
+
+## 逻辑运算符(Logical operators)@Logical-operators
+
+| 运算符       | 范例             | 描述     |
+| ------------ | ---------------- | -------- |
+| 逻辑与(&&)   | condition1 && condition2   | (逻辑与) |
+| 逻辑或(\|\|) | condition1 \|\| condition2 | (逻辑或) |
+| 逻辑非(!)    | !condition1            | (逻辑非) |
+
+**注意**
+
+逻辑运算符操作数的类型必须是 boolean，目前不支持将操作数自动转化为布尔类型。
+
+## 字符串运算符(String operators)@String-operators
+
+除了比较操作符，它可以在字符串值中使用，连接操作符（+）连接两个字符串值相连接，返回另一个字符串，它是两个操作数串的结合。
+
+```ts
+console.log("my " + "string"); // console logs the string "my string".
+```
+**注意**
+
+在iOS平台，连接操作符（+）目前仅支持字符串的连接，即+操作符前后都必须是字符串类型。
+
+## 条件（三元）运算符(Conditional operator) @Conditional-operator
+
+条件运算符是 uts 中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：
+
+`条件 ? 值1 : 值2`
+
+```ts
+const status = age >= 18 ? "adult" : "minor";
+```
+
+## 操作符列表
+
+- `+`
+    * 相加运算符 (+) 用于对两个操作数进行相加运算。
+- `+=`
+    * 加法赋值操作符 (+=) 将右操作数的值添加到变量，并将结果分配给该变量。两个操作数的类型确定加法赋值运算符的行为。
+- `=`
+    * 简单赋值操作符 (=) 用于为变量赋值。赋值表达式本身的值为要赋值的值。
+- `&`
+    * 按位与运算符 (&) 在两个操作数对应的二进位都为 1 时，该位的结果值才为 1，否则为 0。
+- `&=`
+    * 按位与赋值运算符（＆=）表示两个操作数的二进制，对它们进行按位 AND 运算并将结果分配给变量。
+- `~`
+    * 按位非运算符（~），反转操作数的位。
+- `|`
+    * 按位或运算符（|），如果两位之一为 1 则设置每位为 1。
+- `|=`
+    * 按位或赋值操作符 (|=) 使用二进制表示操作数，进行一次按位或操作并赋值。
+- `^`
+    * 按位异或运算符（^），如果两位只有一位为 1 则设置每位为 1。
+- `^=`
+    * 按位异或赋值操作符 (^=) 使用二进制表示操作数，进行一次按位异或操作并赋值。
+- `?`
+- `--`
+    * 自减运算符 (--) 将它的操作数减一，然后返回操作数。
+- `/`
+    * 除法运算符 (/) 计算了两个操作数的商，左边的数是被除数，右边的是除数。
+- `/=`
+- `==`
+- `>`
+    * 当左边操作数大于右边的时候，大于 (>) 运算符返回true，否则返回false。
+- `>=`
+    * 当左边操作数大于等于右边的时候，大于等于 (>=) 运算符返回true，否则返回false。
+- `++`
+    * 自增运算符 (++) 将其操作数递增（加 1）并返回一个值。
+- `!=`
+- `<<`
+    * 左移操作符 (<<) 将第一个操作数向左移动指定位数，左边超出的位数将会被清除，右边将会补零。
+- `<<=`
+    * 左移赋值运算符 (<<=) 将变量向左移动指定数量的位，并将结果赋值给变量。
+- `<`
+    * 当左边操作数小于右边的时候，小于 (<) 运算符返回true，否则返回false。
+- `<=`
+    * 当左边操作数小于等于右边的时候，小于等于 (>=) 运算符返回true，否则返回false。
+- `&&`
+    * 逻辑与
+- `&&=`
+    * Kotlin、Swift 不支持
+- `!`
+- `??=`
+- `||`
+    * 逻辑或。
+- `||=`
+    * 逻辑或赋值（x ||= y）运算仅在 x 为虚值时赋值。
+    * Kotlin、Swift 不支持
+- `*`
+    * 乘法运算符 (*) 计算操作数的乘积。
+- `*=`
+- `??`
+- `?.`
+    * 可选链运算符（?.）允许读取位于连接对象链深处的属性的值，而不必明确验证链中的每个引用是否有效。?. 运算符的功能类似于 . 链式运算符，不同之处在于，在引用为空 (nullish ) (null) 的情况下不会引起错误。
+- `%`
+    * 当一个操作数除以第二个操作数时，取余运算符（％）返回剩余的余数。它与被除数的符号保持一致。
+- `%=`
+- `>>`
+    * 右移操作符 (>>) 是将一个操作数按指定移动的位数向右移动，右边移出位被丢弃，左边移出的空位补符号位（最左边那位）。
+- `>>=`
+    * 右移赋值运算符 (>>=) 将变量向右移动指定数量的位，并将结果赋值给变量。
+- `===`
+    * 当两边操作数指向同一个对象时，引用相等 (===) 运算符返回true。不同平台有差距，[见下](#completecomparison)
+- `!==`
+    * 当两边操作数不指向同一个对象时，引用不等 (!==) 运算符返回true。
+- `-`
+- `-=`
+- `>>>`
+    * 无符号右移运算符（>>>）（零填充右移）将第一个操作数向右移动指定（二进制）位数。
+- `>>>=`
+
+
+## 算数运算符的跨数字类型注意@arithmeticdifftype
+
+uts 中算数运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与运算时，不同平台可能会有不同的表现。
+算数运算符 + - * / % 行为一致，下表以 + 和 / 为例列出了各种场景下的详细差异。
+
+- 其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量
+- 运算符 / 在 字面量 / 字面量场景下, 结果为 number.
+
+| 场景                                 | 示例                                           | Kotlin 结果                   |  Swift 结果 							  |
+| ----------------------------------- | -------------------------------------------   | ------------------------------ |------------------------------------------|
+| number + - * / % number                      | number + number            				  | 结果为 number                   |结果为 number				              |
+| number + - * / % 字面量 #{rowspan=2}| number + 1                                   | 结果为 number                   |结果为 number 						 	  |
+| number + 3.14      						  | 结果为 number                   |结果为 number 							  |
+| number + - * / % 变量 #{rowspan=4}| let a: Int = 1; number + a     			  | 结果为 number      			   |结果为 number 						   	  |
+| let b: Double = 1;  number + b       		  | 结果为 number        		   |结果为 number 						      |
+| let c: Long = 1; number + c 				  | 结果为 number       			   |Swift 中无 Long 							  |
+| let d: Int64 = 1; number+ d      			  | Kotlin 中无 Int64      		   |结果为 number							  |
+| 字面量 + - * / % number #{rowspan=2}| 1 + number 								  | 结果为 number                   |结果为 number 							  |
+| 3.14 + number 								  | 结果为 number                   |结果为 number 							  |
+| 变量 + - * / % number #{rowspan=4}| let a: Int = 1; a + number 				  | 结果为 number                   |编译失败，需要用 (a as number) + number 	  |
+| let b: Double = 1; b + number 				  | 结果为 number                   |编译失败，需要用 (b as number) + number	  |
+| let c: Long = 1;  c + number  				  | 结果为 number                   |Swift 中无 Long 	  						  |
+| let d: Int64 = 1; d + number 				  | Kotlin 中无 Int64              |编译失败，需要用 (d as number) + number	  |
+| 字面量 + - * % 字面量 #{rowspan=3}| 1 + 1 				  						  | 结果为 2 Int                    |结果为2 Int                          	  |
+| 1 + 3.14 				  					  | 结果为4.14 Double               |结果为4.14 Double	  					  |
+| 1.0 + 3.14  				                  | 结果为4.14 Double               |结果为4.14 Double 	 					  |
+| 字面量 / 字面量   			           | 1 / 10 				  					  | 无明确类型时为 0.1 number，有类型时遵守类型约定|无明确类型时为 0.1 number，有类型时遵守类型约定|
+| 专有类型变量 / 字面量 #{rowspan=2}| let a: Int = 2; a / 10				  		  | 结果为 0 Int                    |结果为0 Int                          	  |
+| let a: Int = 2; a / 10.0 				  	  | 结果为 0.2 Double               |编译失败，Int / Double 不合法 需使用 a / Int(10.0)	|
+| 专有类型变量 + - * % 字面量 #{rowspan=2}| let a: Int = 2; a + 10				  		  | 结果为 12 Int                   |结果为12 Int                          	  |
+| let a: Int = 2; a + 3.14 				  	  | 结果为 5.14 Double              |编译失败, 需要 a + Int(3.14) = 5	          |
+| 相同的专有类型变量 + - * / % 操作 #{rowspan=2}| let a: Int = 1; let b: Int = 2; a + b		  | 结果为 3 Int                    |结果为3 Int                          	  |
+| let a: Double = 1.0; let b: Double = 2.0; a + b | 结果为 3.0 Double            |结果为 3.0 Double	          			  |
+| 不同的专有类型变量 + - * / % 操作 #{rowspan=2}| let a: Int = 1; let b: Float = 3.14.toFloat(); a + b	  | 结果为4.14, Float   |编译失败，不同类型变量不能操作                 |
+| let a: Float = 1.0.toFloat(); let b: Double = 3.14; a + b| 结果为4.14，Double |编译失败，不同类型变量不能操作          		  |
+
+number 和平台专有类型的 + - * / % 规则：
+- number 在左侧，平台专有类型在右侧，可以进行 + - * / % 操作，其结果是 number. (安卓平台支持所有的专有类型，iOS平台目前支持 Int Double Float Float64 Float32 类型)
+- 平台专有类型在左侧，number在右侧，可以进行  + - * / % 操作，其结果是 number. (安卓平台支持所有的专有类型，iOS平台需要将左侧的专有类型变量 as 成 number)
+
+
+
+## 比较运算符的跨数字类型注意@comparisondifftype
+
+uts 中比较运算符在大部分场景下和 ts 中的行为一致，但是在有字面量或者是平台专有数字类型参与比较操作时，不同平台可能会有不同的表现。
+
+### 比较运算符 > >= < <=
+
+比较运算符 > >= < <= 行为一致，下表以 > 为例列出了各种场景下的详细差异。
+
+- 其中 number 是指 number 类型的变量，字面量是指数字字面量，变量是指平台专有数字类型的变量
+
+| 场景                                 | 示例                                           | Kotlin 结果                   |  Swift 结果 							  |
+| -----------------------------------  | -------------------------------------------   | ------------------------------ |-----------------------------------------|
+| number > number                      | number > number            				  | 结果为 true or false            |结果为 true or false  				      |
+| number > 字面量                       | number > 1                                   | 结果为 true or false            |结果为 true or false 					  |
+| number > 变量                         | let a: Int = 1; number > a     			  | 结果为 true or false      	   |结果为 true or false 					  |
+| 字面量 > number				       | 3.14 > number 								  | 结果为 true or false            |结果为 true or false 					  |
+| 变量 > number				           | let a: Int = 1; a > number 				  | 结果为 true or false            |结果为 true or false  	  				  |
+| 字面量 > 字面量   			           | 3.14 > 1 				  					  | 结果为 true                     |结果为 true                          	  |
+| 专有类型变量 > 字面量                   | let a: Int = 2; a > 3.14				  	  | 结果为 false                    |结果为 false                          	  |
+| 相同的专有类型变量比较                   | let a: Int = 2; let b: Int = 1; a > b		  | 结果为 true                     |结果为 true                         	      |
+| 不同的专有类型变量比较                   | let a: Int = 1; let b: Float = 3.14.toFloat(); a > b	  | 结果为false         |编译失败，不同类型变量不能比较                 |
+
+
+### 比较运算符 == != === !==@completecomparison
+
+
+| 场景                                  | 示例                                           | Kotlin 结果                   |  Swift 结果 							  |
+| ------------------------------------ | -------------------------------------------   | ------------------------------ |------------------------------------------|
+| number == number (!= === !== 行为相同) | number == number            				  | 值相同就true                     |值相同就true				                  |
+| number == 字面量 (!= === !== 行为相同)  | number == 1                                 | 值相同就true                     |值相同就true 						 	  |
+| number == 变量 (!= === !== 行为相同)   | let a: Int = 1; number == a     			  | 值相同就true      			   |值相同就true 						   	      |
+| 字面量 == number (!= === !== 行为相同) | 1 == number 								  | 值相同就true                     |值相同就true 							  |
+| 变量 == number	 (!= === !== 行为相同)  | let a: Int = 1; a == number 				  | 值相同就true                    |值相同就true 	  							  |
+| 字面量 == 字面量  (!= 行为相同)		   | 1 == 1 	（相同类型）			  		      | 值相同就true                    |值相同就true                          	  |
+|   				      			   | 1 == 3.14 (不同类型)				  			  | 编译失败，不支持比较               |值相同就为true	  					  |
+| 字面量 === 字面量  (!== 行为相同)		   | 1 === 1 	（相同类型）			  			  | 值相同就true                     |编译失败，=== 和 !== 只能用于引用类型比较      |
+|   				      			   | 1 === 3.14 (不同类型)				  			  | 编译失败，不支持比较               |编译失败，=== 和 !== 只能用于引用类型比较	  |
+| 专有类型变量 == 字面量 (!= 行为相同)     | let a: Int = 2; a == 10	 （相同类型）			  | 值相同就true                     |值相同就true                          	  |
+|   				      			   | let a: Int = 2; a == 3.14 （不同类型）		  | 编译失败，不支持比较              |值相同就true	                               |
+| 专有类型变量 === 字面量 (!== 行为相同)     | let a: Int = 2; a === 10	 （相同类型）		  | 值相同就true                     |编译失败，=== 和 !== 只能用于引用类型比较       |
+|   				      			   | let a: Int = 2; a === 3.14 （不同类型）		  | 编译失败，不支持比较              |编译失败，=== 和 !== 只能用于引用类型比较	       |
+| String  == String (!= 行为相同)        | "a" == "a"		 							   | 结果为 true                   |结果为 true                          	  |
+| String  === String (!== 行为相同)  	| "a" === "a" 									| 结果为 true                  |编译失败，不能比较	          			  |
+| Array  == Array (!= 行为相同)        | [1] == [1]	 							   | 结果为 false                   |结果为 true,数组类型相同，元素相同就为true     |
+| Array  === Array (!== 行为相同)  	| [1] === [1] 									| 结果为 false                  |编译失败，不能比较	          			  |
+
+`===` 和 `!==`，本意是内存地址相同，即不仅值相同，并且是同一份对象。
+
+但不同平台的逻辑略有差异：
+- js中可以比较基础类型。swift中不可以比较基础类型，只能比较对象类型
+- js中比较相同字面量会返回true，比如1===1。但kotlin由于编译优化，可能会把两个字面量映射为同一内存地址，但也可能没有触发编译优化。如果没有优化为同一内存地址，那么kotlin上1===1就会返回false。而swift不允许比较字面量。
+
+对于运行时表示为原生类型的值（例如 Int），引用相等 (===)等价于相等（==）。
+<!-- TODO @yanyilin -->
+
+## 展开语法...
+
+> HBuilderX 3.9+
+
+展开语法可以在函数调用/数组构造时，将数组表达式在语法层面展开。展开语法使用 `...` 操作符表示。
+
+### 构造字面量数组
+
+没有展开语法的时候，只能组合使用 push, splice, concat 等方法，来将已有数组元素变成新数组的一部分。有了展开语法，通过字面量方式，构造新数组会变得更简单、更优雅：
+
+```ts
+const array1 = ['a', 'b']
+const array2 = ['c', ...array1, 'd'] //把array1的内容组合赋值给array2
+```
+
+### 在函数调用时使用展开语法
+
+如果想将数组元素迭代为函数[剩余参数](./function.md#剩余参数)，也可以使用 `...` 操作符。
+
+```ts
+fn('a', ...['b', 'c'])
+```
+
+尤其是列表加载场景，从服务器取到一批新数组，就可以使用`...`快捷的追加到之前的data数组中。
+
+假使uvue的data中定义了一个dataList数组，服务器返回了res，res.data是合法的数组，那么就可以把新数组快捷的追加到dataList数组中。
+
+```ts
+this.dataList.push(...res.data)
+```
+
+
+### 剩余参数
+
+剩余语法 (Rest syntax) 看起来和展开语法完全相同，不同点在于，剩余参数用于解构数组和对象。
+
+从某种意义上说，剩余语法与展开语法是相反的：展开语法将数组展开为其中的各个元素，而剩余语法则是将多个元素收集起来并“凝聚”为单个元素。请参考：[剩余参数](./function.md#剩余参数)。

package/data/uni-app-x-docs/uts/runtime-known-issues.md

@@ -0,0 +1,99 @@
+# UTS 运行时已知问题
+
+本文档用于记录与追踪 UTS 运行时的已知问题，便于定位、规避与修复。
+
+##  java.lang.StackOverflowError
+
+### 问题说明
+
+StackOverflowError通常是由于程序中的递归或方法调用链过深，超出了栈的容量。
+
+一般来说现代的移动硬件设备会给每个线程分配足够的栈空间，因此：
+
++ 绝大多数的栈溢出都是因为程序逻辑问题，触发死循环递归导致
+
++ 极少部分情况是因为程序复杂，控制不善，真实的压栈过深导致。
+
+
+### 死循环递归的情况
+
+举例：
+
+```
+java.lang.StackOverflowError: stack size 8188KB
+11:27:17.144 	at io.dcloud.uts.Map.entrySet(Map.kt:19)
+11:27:17.144 	at io.dcloud.px.r.a(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:3)
+11:27:17.144 	at io.dcloud.uniapp.runtime.CSSStyleDeclaration.putAll(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:1)
+11:27:17.144 	at io.dcloud.uniapp.runtime.UniElementImpl.<init>(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:1381)
+11:27:17.144 	at io.dcloud.uniapp.runtime.UniElementImpl.<init>(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:3400)
+11:27:17.144 	at io.dcloud.uniapp.runtime.UniViewElementImpl.<init>(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:1)
+11:27:17.145 	at io.dcloud.px.v2$d$a.a(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:443)
+11:27:17.145 	at io.dcloud.px.v2.createNode(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:5)
+11:27:17.145 	at io.dcloud.px.v2.createNode(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:1)
+11:27:17.145 	at io.dcloud.uniapp.dom.UniNativeDocumentImpl.createElement(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:10)
+11:27:17.145 	at io.dcloud.uniapp.dom.UniNativeDocumentImpl.createElement(r8-map-id-46ae994bfc64fb01690a5f42986f2c98bdb324bdb5ac5c3a8f6a1696d1eb4611:4)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.mountElement(index.kt:7044)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.processElement(index.kt:6654)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.patch(index.kt:6585)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.mountChildren(index.kt:7093)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.mountChildren$default(index.kt:7087)
+11:27:17.145 	at io.dcloud.uniapp.vue.IndexKt.mountElement(index.kt:7054)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.processElement(index.kt:6654)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.patch(index.kt:6585)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.mountChildren(index.kt:7093)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.mountChildren$default(index.kt:7087)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.mountElement(index.kt:7054)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.processElement(index.kt:6654)
+11:27:17.146 	at io.dcloud.uniapp.vue.IndexKt.patch(index.kt:6585)
+
+```
+
+真实的日志大约4000多行，每一行都是对应的方法栈帧，与常规的Java异常分析不同，栈溢出的错误分析最后或者最初的几个栈帧没有意义。
+
+我们需要分析是在这4000多行中频繁重复出现的方法。通过分析此日志定位到下面几行代码频繁出现
+
+```
+io.dcloud.uniapp.vue.IndexKt.mountChildren(index.kt:7093)
+io.dcloud.uniapp.vue.IndexKt.mountChildren$default(index.kt:7087)
+io.dcloud.uniapp.vue.IndexKt.mountElement(index.kt:7054)
+```
+
+也就是说： mountChildren/mountElement 在一次方法调用中频繁调用自身。这显然是不正常的。
+
+接下来我们的问题就转换为了：
+
+调查 mountChildren/mountElement 多次频繁调用自身的原因，进而解决此问题。
+
+
+### 压栈过深的情况
+
+还有极少部分情况，开发者的逻辑并没有触发死循环递归，而是因为程序控制不善导致，下面列出常见的场景。
+
++ 递归深度过大，超出栈容量。
+
+```
+function  factorial(n: number):number {
+	if (n == 1) return 1;
+	return n * factorial(n - 1); // 深度为 n 的递归
+}
+// 调用 factorial(100000) 可能导致栈溢出
+```
+
++ 非递归方法层层嵌套调用
+
+```
+function methodA() { methodB(); }
+function methodB() { methodC(); }
+// ... 数十层调用 ...
+```
+
+
++ 方法中声明大量局部变量（尤其是对象数组），占用过多栈空间。
+
+```
+function largeLocalVars() {
+    kotlin.Int[] hugeArray = new kotlin.Int[1000000]; // 大对象占用栈帧空间
+}
+```
+
+

package/data/uni-app-x-docs/uts/type-aliases.md

@@ -0,0 +1,43 @@
+# 类型别名（Type Aliases）
+
+使用类型别名可以为任何类型命名。类型别名不支持在局部作用域内定义。
+
+## 一般用法
+
+使用 `type` 关键字来定义类型别名。
+
+```ts
+type Str = string
+type Fn = () => void
+
+const str: Str = 'test'
+const fn: Fn = () => {}
+```
+
+使用类型别名不会创建类型的副本，他和原始类型保持同一份引用。
+
+```ts
+class Person {
+
+}
+type P = Person
+
+const p: P = new Person('Tom')
+```
+
+和 TS 语言中不同的是：UTS 语言中类型别名和原始类型一样也可以作为值使用。
+
+```ts
+const p: Person = new P('Tom')
+```
+
+## 特殊处理
+
+当使用类型别名为对象类型（类型为对象字面量表达式）创建别名的时候，编译器会进行特殊处理编译为同名的 Class，此时也支持在局部作用域内定义。具体参考：[对象类型](./object.md)
+
+```ts
+type Person = {
+    name: string
+    fn: () => void
+}
+```

package/data/uni-app-x-docs/uts/type-compatibility.md

@@ -0,0 +1,133 @@
+# 类型兼容性
+
+由于 UTS 语言最终会转换为 kotlin、swift 等语言，UTS 语言中的接口也更接近 kotlin 中的接口或 swift 中的协议，在类型兼容性判断时与 TS 语言的结构类型系统有着明显的区别：
+
+- TS：如果两个类型的内部结构相似（具有相同的属性和方法），那么它们被认为是兼容的，即使它们的名称不同。
+- UTS：依赖于类型的显式声明，必需是同一个类型或者存在显式的继承/实现关系。
+
+```ts
+interface IPerson {
+    name: string
+    printName(): void
+}
+
+class Person implements IPerson {
+    constructor(public name: string) {}
+    printName(): void {
+        console.log(this.name)
+    }
+}
+
+class Person1 {
+    constructor(public name: string) {}
+    printName(): void {
+        console.log(this.name)
+    }
+}
+
+type PersonObject = {
+    name: string
+    printName(): void
+}
+
+class Person2 extends Person {}
+
+const person: IPerson = new Person('Tom') // 正确，Person 实现自 IPerson
+
+const person1: Person = new Person1('Tom') // 错误，Person 与 Person1 无关只是结构相同
+
+const person2: Person = new Person2('Tom') // 正确，Person2 继承自 Person
+
+const person3: IPerson = {
+    name: 'Tom',
+    printName: function () {
+        console.log(this.name)
+    }
+} as PersonObject // 错误，PersonObject 类型与 IPerson 无关只是结构相同
+```
+
+### 运行时类型保留
+
+不同于ts编译后完全抹除类型，uts在运行时保留了部分类型信息。通常是定义type后，创建此type对应的实例时，会保留此实例的类型信息。
+
+例如：
+
+```ts
+type Obj = {
+  a: number
+}
+const obj = {
+  a: 1
+} as Obj 
+// 此时obj的类型为Obj，运行时可以使用 obj instanceof Obj
+console.log(obj instanceof Obj) // true
+
+const result = JSON.parse<Obj>(`{"a": 1}`) // 此时返回的对象类型为Obj
+console.log(result instanceof Obj) // true
+```
+
+**注意**
+
+- 目前 web端`uni.request`传入泛型时不会创建对应类型的实例，会直接抹除类型信息，后续可能会调整为创建泛型类型对应的实例，请勿利用此特性。
+- web端仅项目内定义的类型可以被实例化，uni-app-x内部定义的类型无法被实例化，例如`const options = { url: 'xxx' } as RequestOptions`，并不会将此对象转化为RequestOptions的实例，运行时也没有`RequestOptions`对应的类型信息。
+- 鸿蒙uts编译为ArkTS时，type仅可作为类型使用，不会将此type作为class实例化，包括变量声明时的类型、JSON.parse泛型参数等等。
+
+### any类型
+
+4.18版本起，uts在编译到js时，any类型会包含null类型。编译为kotlin或swift时any类型包含null
+
+4.18之前的版本uts中any类型不包含null类型。
+
+开发者在定义包含null的any类型时如需同时兼容js产物和kotlin、swift产物需要注意定义为any|null
+
+例如定义可选参数时应使用下面的写法：
+
+```ts
+function test(anything?: any | null) { // 注意带上问号
+  console.log(anything)
+}
+```
+
+**注意**
+- uts编译为ArkTS时any类型存在如下两种情况，如果开发者希望使用ArkTS的any类型可以使用ESObject替代any
+  + uts插件内开发者自行指定的any类型，会被编译为Object类型，此类型不含null、undefined
+  + ArkTS编译器推断出的any类型（ArkTS内为ESObject），此类型包含所有类型，且其使用较为受限。详情参考ArkTS文档：[限制使用esobject类型](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/typescript-to-arkts-migration-guide#限制使用esobject类型?ha_source=Dcloud&ha_sourceId=89000448)
+
+### 可选属性
+
+如果属性在类型中是可选值需要使用下面的写法，不要省略问号和`| null`
+
+```ts
+type Options = {
+  num?: number | null
+}
+```
+
+### void/undefined类型
+
+为保证多端统一应尽量避免使用undefined、void类型，可以使用null代替。如果需要判断是否为null建议使用两个等号，不要使用三个等号（此处使用了js的特性`undefined == null`结果为true）。
+
+### String、Number、Boolean类型
+
+ts内string、number、boolean类型与String、Number、Boolean类型并不相同。
+
+```ts
+let str1: String = '1'
+let str2: string = '2'
+
+str1 = str2 // 不报错
+str2 = str1 // 报错 Type 'String' is not assignable to type 'string'
+```
+
+尽量使用string、number、boolean类型替代String、Number、Boolean类型。
+
+### import type@import-type
+
+> HBuilderX 4.41及之后版本已无此章节描述的限制，import type在uni-app-x项目中可以正常使用。
+
+由于uts会为as为某些类型的对象字面量创建这个类型对应的实例，所以经常会存在一些类型引入后是作为值使用而不是作为类型使用。应尽量不要使用`import type`用法，避免编译结果出错。
+
+```ts
+import type { TypeA } from './type' // 避免使用
+import { TypeA } from './type' // 推荐用法
+```

package/data/uni-app-x-docs/uts/uts-optimize.md

@@ -0,0 +1,33 @@
+# UTS 常见错误修复建议
+
+本文档用于汇总 UTS 开发中的常见编译/类型错误，并给出可直接落地的修复方式。
+
+## 可选属性直接返回导致类型不匹配 @error1
+
+- 问题描述：当函数返回值声明为 `number`，但返回的是可选属性（可能为空）时，编译器会报类型不匹配。
+
+复现代码：
+
+```ts
+type UserProfile = {
+	age? : number
+}
+function getUserAge() : number {
+	const userProfile : UserProfile = {
+	}
+	return userProfile.age
+}
+```
+
+修复代码：为可选属性提供兜底值，确保返回值始终为 `number`。
+
+```ts
+type UserProfile = {
+	age? : number
+}
+function getUserAge() : number {
+	const userProfile : UserProfile = {
+	}
+	return userProfile.age ?? 0
+}
+```