bytefun-ai-mcp
Version:
ByteFun AI MCP服务 - 打通产品设计、UI设计、代码开发的服务平台，支持设计稿转代码和跨平台原生代码开发
286 lines (269 loc) • 52.9 kB
JavaScript
export const understandingCodeFrameworkTemplate = `
# **必须先理解项目代码框架10个知识点**
## 1. **理解View组件的声明和使用规则**
- 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的
- View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView
- 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件
- 所有view组件的声明，必须使用\`findViewById(id: string)\`方法赋值，其中里面的参数\`id\`必须从\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md\`查找获取到正确的id的值
- 禁止修改\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md\`文件里面的代码，此文件只读
- View组件的声明必须在类文件开始时先声明，并且必须要声明具体的View组件类型，不得声明为BaseView，不得在任何函数体里面通过findViewById来声明View组件，比如：
- ✅ 正确的写法：
\`\`\`typescript
public class HomePage extends Page {
private nameTextView: TextView = this.findViewById('nameTextView') as TextView
....
}
\`\`\`
- ❌ 错误的写法（没有声具体的View组件类型）：
\`\`\`typescript
private nameTextView = this.findViewById('nameTextView')
\`\`\`
- ❌ 错误的写法（在函数体里面通过findViewById来声明View组件）：
\`\`\`typescript
private oneFunction() {
const nameTextView: TextView = this.findViewById('nameTextView') as TextView
....
}
\`\`\`
- 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\`visibility\`属性进行设置，不得使用\`station\`属性。
- 所有View组件的normal、readOnly、focus、selected、disabled状态的变化都必须使用view的属性station来直接设置，比如：\`this.nameInputView.station = ViewStation.Focus\`，可选值有：ViewStation.NORMAL、ViewStation.READONLY、ViewStation.FOCUSED、ViewStation.SELECTED、ViewStation.DISABLED。
- 所有View组件(包括BaseView、BaseContainer以及它们的子类)的点击事件，都可以直接在view组件的声明后面添加\`setOnClickListener\`方法来监听点击事件，比如：\`this.xxxContainer.setOnClickListener(() => { this.nameTextView.text = '点击了' + this.nameTextView.text })\`
- 所有的dialog对话框，必须调用Dialog组件的show方法来显示，关闭时必须调用Dialog组件的hide方法来关闭，比如：this.xxxDialog.show()、this.xxxDialog.hide()，禁止使用view的visibility属性来显示隐藏对话框。
- 所有的DropDownMenu下拉菜单，必须调用DropDownMenu组件的show方法来显示，关闭时必须调用DropDownMenu组件的hide方法来关闭，比如：this.xxxDropDownMenu.show()、this.xxxDropDownMenu.hide()，禁止使用view的visibility属性来显示隐藏下拉菜单。
- 所有的SideSlideContainer侧滑容器，必须调用SideSlideContainer组件的show方法来显示，关闭时必须调用SideSlideContainer组件的hide方法来关闭，比如：this.xxxSideSlideContainer.show()、this.xxxSideSlideContainer.hide()，禁止使用view的visibility属性来显示隐藏侧滑容器。
## 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**
- 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法
- 使用'read_file'工具阅读并理解'src/lib/JsonObject.ts'和'src/lib/JsonArray.ts'文件，理解这两个文件定义的json相关的方法
- 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块
- 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。
- 所有的dialog对话框，必须调用Dialog组件的show方法来显示，关闭时必须调用Dialog组件的hide方法来关闭，比如：this.xxxDialog.show()、this.xxxDialog.hide()，禁止使用view的visibility属性来显示隐藏对话框。
- 所有的DropDownMenu下拉菜单，必须调用DropDownMenu组件的show方法来显示，关闭时必须调用DropDownMenu组件的hide方法来关闭，比如：this.xxxDropDownMenu.show()、this.xxxDropDownMenu.hide()，禁止使用view的visibility属性来显示隐藏下拉菜单。
- 所有的SideSlideContainer侧滑容器，必须调用SideSlideContainer组件的show方法来显示，关闭时必须调用SideSlideContainer组件的hide方法来关闭，比如：this.xxxSideSlideContainer.show()、this.xxxSideSlideContainer.hide()，禁止使用view的visibility属性来显示隐藏侧滑容器。
- 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。
- 所有localStorage本地数据存储都必须使用AllFunction的saveDatabaseBoolean、saveDatabaseNumber、saveDatabaseString、saveDatabaseArray、saveDatabaseObject方法来存储数据，使用getDatabaseBoolean、getDatabaseNumber、getDatabaseString、getDatabaseArray、getDatabaseObject方法来获取数据。
## 3. **理解Ref、watch**
- Ref的数据类型只能是以下5中类型：数字使用Ref<number>，字符串使用Ref<string>，布尔量使用Ref<boolean>，对象使用Ref<any>，数组使用Ref<Array<any>>或Ref<Array<any> | null>或Ref<any[]>或Ref<any[] | null>。
- 使用'read_file'工具阅读并理解'src/lib/Ref.ts'文件，理解Ref和watch的定义用法
- watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，第一个参数是监听的Ref数组，第二个参数是监听的回调函数，回调函数中可以做相关UI更新或其他业务逻辑。
- Ref是响应式数据源，watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，比如：
\`\`\`typescript
private nameTextRef: Ref<string> = ref('')
private otherCountRef: Ref<number> = ref(0)
watch([this.nameTextRef, this.otherCountRef], () => {
// 可以先相关的UI更新或业务逻辑
if (this.otherCountRef.value > 5) {
this.nameTextView.text = this.nameTextRef.value + '5'
} else {
this.nameTextView.text = this.nameTextRef.value + '10'
}
})
\`\`\`
- \`src/lib/uilib/Ref.ts\`里面的\`watch\`函数，第一个入参\`refs: Ref<T>[]\`绝对禁止先声明局ref数组部变量再传入，正确的写法应该是直接写数组：\`[ref1, ref2]\`就行
- ❌ 错误的写法：
\`\`\` typescript
const refArray = [ref1, ref2]
watch(refArray, (newValues: T[]) => {
// 监听ref1和ref2的变化
})
\`\`\`
- ✅ 正确的写法：
\`\`\` typescript
watch([ref1, ref2], (newValues: T[]) => {
// 监听ref1和ref2的变化
})
\`\`\`
## 4. **理解setDataList方法的静态数据与动态数据场景**
- 对于动态数据容器ViewPager、ListView的setDataList方法，如果数据是动态的，比如：从后端接口获取的，才能使用setDataList方法来设置数据。静态数据已经在UI页面上写好了，你不得使用setDataList方法来设置数据。
- 判断标准：如果UI页面中已经有完整的轮播项目/列表项目，就是静态数据，如果是网络API返回的数据列表就是动态数据。
- ✅ 静态数据容器（UI页面中已写好内容）：不使用setDataList()
- ✅ 动态数据容器（需要从API获取）：才使用setDataList()
## 5. **View组件，理解每个组件可能里面已经有了响应式数据源，如果组件里面已经有了响应式数据源，那么你不得再自己创建ref变量或者使用onSelectChange等回调触发UI更新**
- 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI。
public initView() {
this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
}
- 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI，比如：
\`\`\`typescript
public initView() {
watch([this.viewPager.currentSelectIndexRef], () => {
this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
})
\`\`\`
- tab组件和轮播组件的选择变化监听，必须使用\`ViewPager\`或\`TabContainer\`的\`onSelectChange(func: (item: any, position: number) => void)\`函数来监听选择变化
## 6. **理解页面跳转**
- 编写跳转页面的代码时，必须要先查看目标页面的ts文件，确认目标页面是否存在，如果存在那么必须要使用\`AllFunction.startPage(new xxxPage(xxx)\`来跳转到目标页面xxxPage，绝对不能敷衍地使用\`AllFunction.showToast\`来模拟提示跳转页面，除非目标页面不存在。
- 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage(this.productID))。
- ❌ 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数。
- 在Application.ts设置跳转启动页，比如：
// 应用网站启动时回调的第一个函数，用于初始化一些全局的东西。
protected onApplicationCreate(): void {
AllFunction.startPage(new SplashPage())
}
- ✅ 引入其他类只允许一种写法：在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
- ❌ 绝对禁止使用动态import的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
// 使用动态导入避免循环依赖
import('../guidePage/guidePage').then(({ default: GuidePage }) => {
AllFunction.startPage(new GuidePage())
})
- ❌ 绝对禁止使用require的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
require('../guidePage/guidePage').default
- ✅ 正确的写法是：AllFunction.startPage(new GuidePage())。然后在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
- 如果页面跳转需要传递参数，那么需要使用Page的子类构造函数来传递参数，比如：AllFunction.startPage(new GuidePage(this.productID))。
- 在实现页面跳转代码的时候，必须严格按照以下三步来实现：
- **第一步：先分析跳转的目标页面需要传递哪些参数**
- **第二步：修改目标页面构造函数**：
\`\`\`typescript
export default class ReadingPage extends Page {
private bookId: number
private chapterTitle: string
constructor(bookId: number, chapterTitle: string) {
super()
this.bookId = bookId
this.chapterTitle = chapterTitle
}
}
\`\`\`
- **第三步：修改跳转代码**
\`\`\`typescript
const bookData = this.readingHistoryDataRef.value[0]
AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))
\`\`\`
## 7. **理解基础开发规则**
- lib文件夹里面的代码文件都是内置框架代码，绝对禁止对lib文件夹的代码进行增删改操作
- 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现
- 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。
- 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。
- 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明
- 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。
- Tab选项卡\`TabNavigateBar\`和\`TabNavigateBarItem\`的点击切换UI更新逻辑，不得在ts代码里面进行，因为Tab选项卡内部已经封装好了滑动和点击切换UI更新逻辑，你不需要再手动实现。
- 底部导航栏\`bottomTabNavigateBar\`和\`bottomTabNavigateBarItem\`的滑动和点击切换UI更新逻辑，不得在ts代码里面进行，因为底部导航栏内部已经封装好了点击切换UI更新逻辑，你不需要再手动实现，比如首页主体页的底部导航栏，不需要实现点击切换UI更新逻辑，因为底部导航栏的点击切换UI更新逻辑已经自动实现了。
- 每一个页面(如loginPage)必须在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面。
## 8. **理解后端API接口的定义与使用**
- 使用'read_file'工具读取'src/backendApi/backendApiInfo.md'后端API使用说明文件，必须缓存记住所有可用的后端API接口列表。
- 后端API接口的定义与使用，必须使用src/backendApi文件夹里面的各种API类中定义的方法，不允许使用未在backendApi文件夹中定义的后端API，比如：backendApi/account/getUserInfo.ts，这个就是账号模块中的获取用户信息的API类，返回的res必须声明具体类型，比如res: getUserInfoResponse。
- request接口只需定义即可，不需要实现，底层已经实现。
- API类代码示例：
\`\`\`typescript
import { NetFailData } from '../../lib/NetFailData'
import BaseApi from '../BaseApi'
// 账号系统-账号密码登录接口请求数据
export interface postClientBizAuthLoginRequest {
username?: string
password?: string
key?: string
captcha?: string
}
// 账号系统-账号密码登录接口返回数据
export interface postClientBizAuthLoginResponse {
code: number
msg: string
data: {
access_token: string
}
}
// 账号系统-账号密码登录接口
export default class postClientBizAuthLogin extends BaseApi {
public static request_ArtuX1d8a6A(
request: postClientBizAuthLoginRequest,
success: (res: postClientBizAuthLoginResponse) => void,
fail: (error: NetFailData) => void
): void { }
}
\`\`\`
- API类的使用方式：先import API类，然后调用API类的request方法，比如：
import { NetFailData } from "../../lib/NetFailData"
import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'
...
const request: postClientBizAuthLoginRequest = {
username: 'admin',
password: '123456',
key: '123456',
captcha: '123456'
}
postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {
// 请求成功后的处理
}, (error: NetFailData) => {
// 请求失败后的处理
})
...
## 9. **理解调用后端api接口返回数据后与UI数据绑定**
- 必须查看xxxPage.md文件里面的该节点是否有声明fromApiOrCacheData(true)的情况，如果有声明表示该节点需要从后端api接口获取数据，那么必须封装一个名字叫做\`bindDataFromNet\`的方法来处理调用后端api接口返回数据后与UI数据绑定的逻辑。
- 在调用后端api接口返回数据后，必须严格参考\`api接口返回数据后与UI数据绑定例子\`，需要根据vtype来做数据绑定
- vtype="verticalListView"、vtype="horizontalListView"、vtype="viewPager"、vtype="radioGroup"、vtype="checkBoxGroup"、vtype="inlineBlockAndWrap"类型的节点组件，需要使用setDataList方法来绑定数据，比如：
this.xxxVerticalListView.setDataList(xxxResponse.data.list)、this.xxxHorizontalListView.setDataList(xxxResponse.xxxList)、this.xxxViewPager.setDataList(xxxResponse.xxxList)
- \`setDataList\`的入参必须是直接写后端api返回的数据路径，比如：xxxResponse.data.xxxList，绝对不能使用全局变量和局部变量进行数据绑定，不能写其他逻辑代码，比如：不能写if、for、while等循环语句，不能写函数调用等。
- vtype="listItemCard"、vtype="oneViewPagerContent"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，并且必须是直接写后端api返回的数据路径的第一个itemData的数据路径，比如：const itemData = dataList[0]; this.recommendBookTitle1.text = itemData.xxx.titleText，绝对不能使用全局变量和局部变量进行数据绑定，不能写其他逻辑代码，比如：不能写if、for、while等循环语句，如果需要逻辑处理后才能得出this.recommendBookTitle1.text的值，那就必须要封装一个\`getxxx(itemData: any): string\`方法来获取，然后:this.recommendBookTitle1.text = this.getxxx(itemData)
- api接口返回数据后与UI数据绑定例子：
\`\`\`typescript
// 后端xxxApi返回的xxxResponse数据结构
export interface getRecommendBookListResponse {
code: number
msg: string
data: {
list: [
{
id: number // 书籍ID
title: string // 书籍标题
author: string // 作者名称
coverUrl: string // 封面图片URL
description: string // 书籍简介
categoryName: string // 分类名称
}
] // 书籍列表
total: number // 总数量
page: number // 当前页码
size: number // 每页数量
}
}
...
private bindDataFromNet(getRecommendBookListData: getRecommendBookListResponse) {
// 设置书籍列表数据
this.recommendBookList.setDataList(getRecommendBookListData.data.listData)
// 设置第1个item节点数据
const listItemData = getRecommendBookListData.data.listData[0]
this.recommendBookCover1.src = listItemData.coverUrl
this.recommendBookTitle1.text = listItemData.title
this.recommendBookAuthor1.text = listItemData.author
...
// 设置轮播数据
this.recommendViewPager.setDataList(getRecommendBookListData.data.viewPagerData)
// 设置第1个item节点数据
const viePagerItemData = getRecommendBookListData.data.viewPagerData[0]
this.recommendImage1.src = viePagerItemData.coverUrl
this.carouselTitle1.text = this.getCarouselTitleData(viePagerItemData) // 由于有复杂的逻辑处理，所以必须要封装一个方法来获取
}
private getCarouselTitleData(itemData: any) {
let title = ''
if (itemData.title) {
title = itemData.title
} else if (itemData.description) {
title = itemData.description
} else {
title = itemData.categoryName
}
return title
}
...
\`\`\`
- 设置第1个item节点数据时，如果表达式右侧涉及逻辑运算，必须封装成一个类成员方法，如：
\`\`\`typescript
// 涉及逻辑运算时改为调用一个类成员方法
this.recommendImage1.src = this.xxxMethod(getRecommendBookListResponse)
// 如果表达式右侧涉及逻辑运算，封装成一个类成员方法
private xxxMethod(res: getRecommendBookListResponse): string {
let tmp = getRecommendBookListResponse.data.list[0].coverUrl
if (tmp && tmp.length > 5) {
return tmp + '长名字'
}
return tmp
}
\`\`\`
## 10. 一些高级View组件内部已封装好逻辑，因此一些View组件不需要做以下事情
- 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。
- Tab选项卡\`TabNavigateBar\`和\`TabNavigateBarItem\`的点击切换UI更新逻辑，不得在ts代码里面进行，因为Tab选项卡内部已经封装好了滑动和点击切换UI更新逻辑，你不需要再手动实现。
- 底部导航栏\`bottomTabNavigateBar\`和\`bottomTabNavigateBarItem\`的滑动和点击切换UI更新逻辑，不得在ts代码里面进行，因为底部导航栏内部已经封装好了点击切换UI更新逻辑，你不需要再手动实现。
- 子页面容器\`SubPageContainer\`不需要编写任何设置页面或切换页面的逻辑。
- 禁止对ImageView进行color属性的设置。
- 多状态容器\`MultiStateContainer\`，禁止对其内部的子View组件进行直接设置，而必须通过\`currentStationRef\`来切换状态，修改\`currentStationRef\`切换状态后就会自动显示该状态下的UI组件，并且隐藏其他状态下的UI组件。
`;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appCodeRule.js","sourceRoot":"","sources":["../src/appCodeRule.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kCAAkC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4RjD,CAAC","sourcesContent":["export const understandingCodeFrameworkTemplate = `\n# **必须先理解项目代码框架10个知识点**\n## 1. **理解View组件的声明和使用规则**\n  - 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的\n  - View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView\n  - 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件\n  - 所有view组件的声明，必须使用\\`findViewById(id: string)\\`方法赋值，其中里面的参数\\`id\\`必须从\\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md\\`查找获取到正确的id的值\n  - 禁止修改\\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md\\`文件里面的代码，此文件只读\n  - View组件的声明必须在类文件开始时先声明，并且必须要声明具体的View组件类型，不得声明为BaseView，不得在任何函数体里面通过findViewById来声明View组件，比如：\n    - ✅ 正确的写法：\n    \\`\\`\\`typescript\n    public class HomePage extends Page {\n      private nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    \\`\\`\\`\n    - ❌ 错误的写法（没有声具体的View组件类型）：\n    \\`\\`\\`typescript\n    private nameTextView = this.findViewById('nameTextView')\n    \\`\\`\\`\n    - ❌ 错误的写法（在函数体里面通过findViewById来声明View组件）：\n    \\`\\`\\`typescript\n    private oneFunction() {\n      const nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    \\`\\`\\`\n  - 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\\`visibility\\`属性进行设置，不得使用\\`station\\`属性。\n  - 所有View组件的normal、readOnly、focus、selected、disabled状态的变化都必须使用view的属性station来直接设置，比如：\\`this.nameInputView.station = ViewStation.Focus\\`，可选值有：ViewStation.NORMAL、ViewStation.READONLY、ViewStation.FOCUSED、ViewStation.SELECTED、ViewStation.DISABLED。\n  - 所有View组件(包括BaseView、BaseContainer以及它们的子类)的点击事件，都可以直接在view组件的声明后面添加\\`setOnClickListener\\`方法来监听点击事件，比如：\\`this.xxxContainer.setOnClickListener(() => { this.nameTextView.text = '点击了' + this.nameTextView.text })\\`\n  - 所有的dialog对话框，必须调用Dialog组件的show方法来显示，关闭时必须调用Dialog组件的hide方法来关闭，比如：this.xxxDialog.show()、this.xxxDialog.hide()，禁止使用view的visibility属性来显示隐藏对话框。\n  - 所有的DropDownMenu下拉菜单，必须调用DropDownMenu组件的show方法来显示，关闭时必须调用DropDownMenu组件的hide方法来关闭，比如：this.xxxDropDownMenu.show()、this.xxxDropDownMenu.hide()，禁止使用view的visibility属性来显示隐藏下拉菜单。\n  - 所有的SideSlideContainer侧滑容器，必须调用SideSlideContainer组件的show方法来显示，关闭时必须调用SideSlideContainer组件的hide方法来关闭，比如：this.xxxSideSlideContainer.show()、this.xxxSideSlideContainer.hide()，禁止使用view的visibility属性来显示隐藏侧滑容器。\n\n## 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**\n  - 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法\n  - 使用'read_file'工具阅读并理解'src/lib/JsonObject.ts'和'src/lib/JsonArray.ts'文件，理解这两个文件定义的json相关的方法\n  - 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块\n  - 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。\n  - 所有的dialog对话框，必须调用Dialog组件的show方法来显示，关闭时必须调用Dialog组件的hide方法来关闭，比如：this.xxxDialog.show()、this.xxxDialog.hide()，禁止使用view的visibility属性来显示隐藏对话框。\n  - 所有的DropDownMenu下拉菜单，必须调用DropDownMenu组件的show方法来显示，关闭时必须调用DropDownMenu组件的hide方法来关闭，比如：this.xxxDropDownMenu.show()、this.xxxDropDownMenu.hide()，禁止使用view的visibility属性来显示隐藏下拉菜单。\n  - 所有的SideSlideContainer侧滑容器，必须调用SideSlideContainer组件的show方法来显示，关闭时必须调用SideSlideContainer组件的hide方法来关闭，比如：this.xxxSideSlideContainer.show()、this.xxxSideSlideContainer.hide()，禁止使用view的visibility属性来显示隐藏侧滑容器。\n  - 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。\n  - 所有localStorage本地数据存储都必须使用AllFunction的saveDatabaseBoolean、saveDatabaseNumber、saveDatabaseString、saveDatabaseArray、saveDatabaseObject方法来存储数据，使用getDatabaseBoolean、getDatabaseNumber、getDatabaseString、getDatabaseArray、getDatabaseObject方法来获取数据。\n\n## 3. **理解Ref、watch**\n  - Ref的数据类型只能是以下5中类型：数字使用Ref<number>，字符串使用Ref<string>，布尔量使用Ref<boolean>，对象使用Ref<any>，数组使用Ref<Array<any>>或Ref<Array<any> | null>或Ref<any[]>或Ref<any[] | null>。\n  - 使用'read_file'工具阅读并理解'src/lib/Ref.ts'文件，理解Ref和watch的定义用法\n  - watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，第一个参数是监听的Ref数组，第二个参数是监听的回调函数，回调函数中可以做相关UI更新或其他业务逻辑。\n  - Ref是响应式数据源，watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，比如：\n  \\`\\`\\`typescript\n  private nameTextRef: Ref<string> = ref('')\n  private otherCountRef: Ref<number> = ref(0)\n  watch([this.nameTextRef, this.otherCountRef], () => {\n    // 可以先相关的UI更新或业务逻辑\n    if (this.otherCountRef.value > 5) {\n      this.nameTextView.text = this.nameTextRef.value + '5'\n     } else {\n      this.nameTextView.text = this.nameTextRef.value + '10'\n    }\n  })\n  \\`\\`\\`\n  - \\`src/lib/uilib/Ref.ts\\`里面的\\`watch\\`函数，第一个入参\\`refs: Ref<T>[]\\`绝对禁止先声明局ref数组部变量再传入，正确的写法应该是直接写数组：\\`[ref1, ref2]\\`就行\n  - ❌ 错误的写法：\n    \\`\\`\\` typescript\n    const refArray = [ref1, ref2]\n    watch(refArray, (newValues: T[]) => {\n        // 监听ref1和ref2的变化\n    })\n    \\`\\`\\`\n  - ✅ 正确的写法：\n    \\`\\`\\` typescript\n    watch([ref1, ref2], (newValues: T[]) => {\n        // 监听ref1和ref2的变化\n    })\n    \\`\\`\\`\n\n## 4. **理解setDataList方法的静态数据与动态数据场景**\n  - 对于动态数据容器ViewPager、ListView的setDataList方法，如果数据是动态的，比如：从后端接口获取的，才能使用setDataList方法来设置数据。静态数据已经在UI页面上写好了，你不得使用setDataList方法来设置数据。\n  - 判断标准：如果UI页面中已经有完整的轮播项目/列表项目，就是静态数据，如果是网络API返回的数据列表就是动态数据。\n  - ✅ 静态数据容器（UI页面中已写好内容）：不使用setDataList()\n  - ✅ 动态数据容器（需要从API获取）：才使用setDataList()\n\n## 5. **View组件，理解每个组件可能里面已经有了响应式数据源，如果组件里面已经有了响应式数据源，那么你不得再自己创建ref变量或者使用onSelectChange等回调触发UI更新**\n  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI。\n    public initView() {\n      this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length\n    }\n  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI，比如：\n    \\`\\`\\`typescript\n    public initView() {\n      watch([this.viewPager.currentSelectIndexRef], () => {\n        this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length\n      })\n    \\`\\`\\`\n  - tab组件和轮播组件的选择变化监听，必须使用\\`ViewPager\\`或\\`TabContainer\\`的\\`onSelectChange(func: (item: any, position: number) => void)\\`函数来监听选择变化\n\n## 6. **理解页面跳转**\n  - 编写跳转页面的代码时，必须要先查看目标页面的ts文件，确认目标页面是否存在，如果存在那么必须要使用\\`AllFunction.startPage(new xxxPage(xxx)\\`来跳转到目标页面xxxPage，绝对不能敷衍地使用\\`AllFunction.showToast\\`来模拟提示跳转页面，除非目标页面不存在。\n  - 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage(this.productID))。\n  - ❌ 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数。\n  - 在Application.ts设置跳转启动页，比如：\t\n    // 应用网站启动时回调的第一个函数，用于初始化一些全局的东西。\n    protected onApplicationCreate(): void {\n      AllFunction.startPage(new SplashPage())\n    }\n  - ✅ 引入其他类只允许一种写法：在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。\n  - ❌ 绝对禁止使用动态import的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：\n        // 使用动态导入避免循环依赖\n        import('../guidePage/guidePage').then(({ default: GuidePage }) => {\n            AllFunction.startPage(new GuidePage())\n        })\n  - ❌ 绝对禁止使用require的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：\n        require('../guidePage/guidePage').default\n  - ✅ 正确的写法是：AllFunction.startPage(new GuidePage())。然后在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。\n  - 如果页面跳转需要传递参数，那么需要使用Page的子类构造函数来传递参数，比如：AllFunction.startPage(new GuidePage(this.productID))。\n  - 在实现页面跳转代码的时候，必须严格按照以下三步来实现：\n      - **第一步：先分析跳转的目标页面需要传递哪些参数**\n      - **第二步：修改目标页面构造函数**：\n      \\`\\`\\`typescript\n      export default class ReadingPage extends Page {\n          private bookId: number\n          private chapterTitle: string\n          \n          constructor(bookId: number, chapterTitle: string) {\n              super()\n              this.bookId = bookId\n              this.chapterTitle = chapterTitle\n          }\n      }\n      \\`\\`\\`\n      - **第三步：修改跳转代码**\n      \\`\\`\\`typescript\n      const bookData = this.readingHistoryDataRef.value[0]\n      AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))\n      \\`\\`\\`\n\n## 7. **理解基础开发规则**\n  - lib文件夹里面的代码文件都是内置框架代码，绝对禁止对lib文件夹的代码进行增删改操作\n  - 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现\n  - 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。\n  - 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。\n  - 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明\n  - 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。\n  - Tab选项卡\\`TabNavigateBar\\`和\\`TabNavigateBarItem\\`的点击切换UI更新逻辑，不得在ts代码里面进行，因为Tab选项卡内部已经封装好了滑动和点击切换UI更新逻辑，你不需要再手动实现。\n  - 底部导航栏\\`bottomTabNavigateBar\\`和\\`bottomTabNavigateBarItem\\`的滑动和点击切换UI更新逻辑，不得在ts代码里面进行，因为底部导航栏内部已经封装好了点击切换UI更新逻辑，你不需要再手动实现，比如首页主体页的底部导航栏，不需要实现点击切换UI更新逻辑，因为底部导航栏的点击切换UI更新逻辑已经自动实现了。\n  - 每一个页面(如loginPage)必须在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面。\n\n## 8. **理解后端API接口的定义与使用**\n  - 使用'read_file'工具读取'src/backendApi/backendApiInfo.md'后端API使用说明文件，必须缓存记住所有可用的后端API接口列表。\n  - 后端API接口的定义与使用，必须使用src/backendApi文件夹里面的各种API类中定义的方法，不允许使用未在backendApi文件夹中定义的后端API，比如：backendApi/account/getUserInfo.ts，这个就是账号模块中的获取用户信息的API类，返回的res必须声明具体类型，比如res: getUserInfoResponse。\n  - request接口只需定义即可，不需要实现，底层已经实现。\n  - API类代码示例：\n    \\`\\`\\`typescript\n    import { NetFailData } from '../../lib/NetFailData'\n    import BaseApi from '../BaseApi'\n\n    // 账号系统-账号密码登录接口请求数据\n    export interface postClientBizAuthLoginRequest {\n        username?: string\n        password?: string\n        key?: string\n        captcha?: string\n    }\n\n    // 账号系统-账号密码登录接口返回数据\n    export interface postClientBizAuthLoginResponse {\n                    code: number\n                    msg: string\n                    data: {\n        access_token: string\n        }\n    }\n\n    // 账号系统-账号密码登录接口\n    export default class postClientBizAuthLogin extends BaseApi  {\n\n        public static request_ArtuX1d8a6A(\n            request: postClientBizAuthLoginRequest,\n            success: (res: postClientBizAuthLoginResponse) => void,\n            fail: (error: NetFailData) => void\n        ): void { }\n\n    }\n    \\`\\`\\`\n  - API类的使用方式：先import API类，然后调用API类的request方法，比如：\n    import { NetFailData } from \"../../lib/NetFailData\"\n    import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'\n    ...\n    const request: postClientBizAuthLoginRequest = {\n      username: 'admin',\n      password: '123456',\n      key: '123456',\n      captcha: '123456'\n    }\n    postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {\n      // 请求成功后的处理\n    }, (error: NetFailData) => {\n      // 请求失败后的处理\n    })\n    ...\n\n## 9. **理解调用后端api接口返回数据后与UI数据绑定**\n  - 必须查看xxxPage.md文件里面的该节点是否有声明fromApiOrCacheData(true)的情况，如果有声明表示该节点需要从后端api接口获取数据，那么必须封装一个名字叫做\\`bindDataFromNet\\`的方法来处理调用后端api接口返回数据后与UI数据绑定的逻辑。\n  - 在调用后端api接口返回数据后，必须严格参考\\`api接口返回数据后与UI数据绑定例子\\`，需要根据vtype来做数据绑定\n    - vtype=\"verticalListView\"、vtype=\"horizontalListView\"、vtype=\"viewPager\"、vtype=\"radioGroup\"、vtype=\"checkBoxGroup\"、vtype=\"inlineBlockAndWrap\"类型的节点组件，需要使用setDataList方法来绑定数据，比如：\n      this.xxxVerticalListView.setDataList(xxxResponse.data.list)、this.xxxHorizontalListView.setDataList(xxxResponse.xxxList)、this.xxxViewPager.setDataList(xxxResponse.xxxList)\n    - \\`setDataList\\`的入参必须是直接写后端api返回的数据路径，比如：xxxResponse.data.xxxList，绝对不能使用全局变量和局部变量进行数据绑定，不能写其他逻辑代码，比如：不能写if、for、while等循环语句，不能写函数调用等。\n    - vtype=\"listItemCard\"、vtype=\"oneViewPagerContent\"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，并且必须是直接写后端api返回的数据路径的第一个itemData的数据路径，比如：const itemData = dataList[0]; this.recommendBookTitle1.text = itemData.xxx.titleText，绝对不能使用全局变量和局部变量进行数据绑定，不能写其他逻辑代码，比如：不能写if、for、while等循环语句，如果需要逻辑处理后才能得出this.recommendBookTitle1.text的值，那就必须要封装一个\\`getxxx(itemData: any): string\\`方法来获取，然后:this.recommendBookTitle1.text = this.getxxx(itemData)\n    - api接口返回数据后与UI数据绑定例子：\n      \\`\\`\\`typescript\n      // 后端xxxApi返回的xxxResponse数据结构\n      export interface getRecommendBookListResponse {\n          code: number\n          msg: string\n          data: {\n              list: [\n                  {\n                      id: number // 书籍ID\n                      title: string // 书籍标题\n                      author: string // 作者名称\n                      coverUrl: string // 封面图片URL\n                      description: string // 书籍简介\n                      categoryName: string // 分类名称\n                  }\n              ] // 书籍列表\n              total: number // 总数量\n              page: number // 当前页码\n              size: number // 每页数量\n          }\n      }\n      ...\n      private bindDataFromNet(getRecommendBookListData: getRecommendBookListResponse) {\n        // 设置书籍列表数据\n        this.recommendBookList.setDataList(getRecommendBookListData.data.listData)\n        // 设置第1个item节点数据\n        const listItemData = getRecommendBookListData.data.listData[0]\n        this.recommendBookCover1.src = listItemData.coverUrl\n        this.recommendBookTitle1.text = listItemData.title\n        this.recommendBookAuthor1.text = listItemData.author\n        ...\n        // 设置轮播数据\n        this.recommendViewPager.setDataList(getRecommendBookListData.data.viewPagerData)\n        // 设置第1个item节点数据\n        const viePagerItemData = getRecommendBookListData.data.viewPagerData[0]\n        this.recommendImage1.src = viePagerItemData.coverUrl\n        this.carouselTitle1.text = this.getCarouselTitleData(viePagerItemData) // 由于有复杂的逻辑处理，所以必须要封装一个方法来获取\n      }\n      private getCarouselTitleData(itemData: any) {\n        let title = ''\n        if (itemData.title) {\n          title = itemData.title\n        } else if (itemData.description) {\n          title = itemData.description\n        } else {\n          title = itemData.categoryName\n        }\n        return title\n      }\n      ...\n      \\`\\`\\`\n    - 设置第1个item节点数据时，如果表达式右侧涉及逻辑运算，必须封装成一个类成员方法，如：\n      \\`\\`\\`typescript\n      // 涉及逻辑运算时改为调用一个类成员方法\n      this.recommendImage1.src = this.xxxMethod(getRecommendBookListResponse)\n      // 如果表达式右侧涉及逻辑运算，封装成一个类成员方法\n      private xxxMethod(res: getRecommendBookListResponse): string {\n        let tmp = getRecommendBookListResponse.data.list[0].coverUrl\n        if (tmp && tmp.length > 5) {\n            return tmp + '长名字'\n        }\n        return tmp\n      }\n      \\`\\`\\`\n    \n\n## 10. 一些高级View组件内部已封装好逻辑，因此一些View组件不需要做以下事情\n- 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。\n- Tab选项卡\\`TabNavigateBar\\`和\\`TabNavigateBarItem\\`的点击切换UI更新逻辑，不得在ts代码里面进行，因为Tab选项卡内部已经封装好了滑动和点击切换UI更新逻辑，你不需要再手动实现。\n- 底部导航栏\\`bottomTabNavigateBar\\`和\\`bottomTabNavigateBarItem\\`的滑动和点击切换UI更新逻辑，不得在ts代码里面进行，因为底部导航栏内部已经封装好了点击切换UI更新逻辑，你不需要再手动实现。\n- 子页面容器\\`SubPageContainer\\`不需要编写任何设置页面或切换页面的逻辑。\n- 禁止对ImageView进行color属性的设置。\n- 多状态容器\\`MultiStateContainer\\`，禁止对其内部的子View组件进行直接设置，而必须通过\\`currentStationRef\\`来切换状态，修改\\`currentStationRef\\`切换状态后就会自动显示该状态下的UI组件，并且隐藏其他状态下的UI组件。\n\n`;\n"]}