bytefun-ai-mcp 1.13.98 → 1.13.100

package/build/appCode.js

@@ -1,4 +1,4 @@
-export const codePromptTemplate = `# 你是typescript代码专家，根据用户输入的需求描述，严格遵守\`代码规范\`，参考\`代码例子\`，严格按照\`编写代码的9 个步骤\`完成代码开发
+export const codePromptTemplate = `# 你是typescript代码专家，根据用户输入的需求描述，严格遵守\`代码规范\`，参考\`代码例子\`，严格按照\`编写代码的10 个步骤\`完成代码开发
 
 ## 代码规范
 - **代码注释使用中文**：代码的注释文字，必须要使用中文，不能使用其他语言
@@ -32,320 +32,60 @@ export const codePromptTemplate = `# 你是typescript代码专家，根据用户
   - 登录页
     - 登录页是用户点击需要登录才能访问的页面时，才会跳转到的页面，而不是从闪屏页判断是否需要登录然后跳进去
 
-## 调用 todo_write 工具创建编写代码的 9 个任务列表，必须按照以下 9 个任务创建任务列表，禁止跳过任何任务
+## **执行业务逻辑代码实现：每一个页面业务逻辑代码实现都必须调用 todo_write 工具创建以下 10 个任务列表，创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。**
 
-### **第1个任务：阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
+1. 严格按照\`步骤规则1\`执行任务，阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
+2. 严格按照\`步骤规则2\`执行任务，在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发
+3. 严格按照\`步骤规则3\`执行任务，使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用
+4. 严格按照\`步骤规则4\`执行任务，使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据
+5. 严格按照\`步骤规则5\`执行任务，为刷新记忆缓存，你必须重新调用MCP工具\`understanding_code_framework_prompt\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点
+6. 严格按照\`步骤规则6\`执行任务，结合第5个任务理解的11个知识点以及\`代码例子\`，开始编写代码
+7. 严格按照\`步骤规则7\`执行任务，执行\`npm run lint-ts\`命令检查特殊编译问题。
+8. 严格按照\`步骤规则8\`执行任务，执行\`npm run build\`编译命令检查编译问题。
+9. 严格按照\`步骤规则9\`执行任务，必须强制更新\`doc/前端代码开发进度.json\`文件\`version\`和\`codeStatus\`属性
+10. 严格按照\`步骤规则10\`执行任务，调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规
 
-### **第2个任务：在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发2**
+### **步骤规则1：阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
 
-### **第3个任务：使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用**
+### **步骤规则2：在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发**
 
-### **第4个任务：使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据**
+### **步骤规则3：使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用**
 
-### **第5个任务：必须先理解项目代码框架11个知识点**
-#### 1. **理解View组件的声明规则**
-  - 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的
-  - View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView
-  - 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件
-  - 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组件的选中状态、聚焦状态、禁用状态的变化都必须通过\`setStation(station: ViewStation)\`函数来设置，不能直接设置组件的UI属性，只需要设置组件的station属性即可自动更新组件的UI样式
-  - 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\`visibility\`属性进行设置，不得使用\`station\`属性。
-  - 所有View组件的normal、readOnly、focus、selected、disabled状态的设置都必须使用View的\`station\`属性进行设置。
-
-#### 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**
-  - 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法
-  - 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块
-  
-#### 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. **理解页面跳转**
-  - 页面跳转必须使用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文件夹的代码进行增删改操作
-  - 所有Page的子类，都允许添加构造函数和构造函数的参数，这些参数就用来页面跳转时页面之间传递数据使用，比如：商品列表页ProjectListPage跳到商品详情页ProjectDetailPage，那么ProjectListPage应该要传给ProjectDetailPage一个参数：productID。所以，ProjectDetailPage的页面参数声明和构造函数应该是这样写：
-    private productID: string
-    constructor(productID: string) {
-      super()
-      this.productID = productID
-    }。
-  - 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现
-  - 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。
-  - 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。
-  - 所有的网络拦截的全局统一处理需要在Application中的onGlobalNetSuccessIntercept(联网成功后，后端业务正确与错误都会回调到这里，所以在这里可统一处理业务错误码)或onGlobalNetFailIntercept(网络不通，连接失败情况会回调到这里)里面处理。
-  - 页面内的网络请求业务处理不得写在Application的onGlobalNetSuccessIntercept里面。
-  - 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明
-  - 字符串不得直接进行boolean运算然后赋值给boolean类型的变量，需要在字符串前面添加两个非运算：!!。比如正确的写法：const isAdd = !!this.inputView.text && isNew
-  - 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。
-  - 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。
-  - 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。
-  - 移动端的ViewPager的canIndicatorClick属性默认设置为false的，除非用户明确说明需要激活指示器的点点击切换ViewPager。
-  - 每一个页面(如loginPage)建议在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面，页面文件夹下如果需要还可创建一个页面数据ts文件(如loginPageData.ts)，这样如loginPage负责业务逻辑和交互逻辑，如loginPageData负责数据声明定义、初始化与管理等。
-
-#### 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 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
-        }
-    }
+### **步骤规则4：使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据**
 
-    // 账号系统-账号密码登录接口失败返回数据
-    export interface apiFailInfo {
-        msg: string
-        code: number
-    }
+### **步骤规则5：为刷新记忆缓存，你必须重新调用MCP工具\`understanding_code_framework_prompt\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点**
 
-    // 账号系统-账号密码登录接口
-    export default class postClientBizAuthLogin extends BaseApi  {
-
-        public static request_ArtuX1d8a6A(
-            request: postClientBizAuthLoginRequest,
-            success: (res: postClientBizAuthLoginResponse) => void,
-            fail: (error: apiFailInfo) => void
-        ): void { }
-
-    }
-    \`\`\`
-  - API类的使用方式：先import API类，然后调用API类的request方法，比如：
-    import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'
-    ...
-    const request: postClientBizAuthLoginRequest = {
-      username: 'admin',
-      password: '123456',
-      key: '123456',
-      captcha: '123456'
-    }
-    postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {
-      // 请求成功后的处理
-    }, (error: apiFailInfo) => {
-      // 请求失败后的处理
-    })
-    ...
-
-#### 9. **理解调用后端api接口返回数据后与UI数据绑定**
-  - 在调用后端api接口返回数据后，需要根据vtype来做不同的数据绑定，比如：
-    - vtype="verticalListView"、vtype="horizontalListView"、vtype="viewPager"类型的节点组件，需要使用setDataList方法来绑定数据，比如：
-      this.xxxVerticalListView.setDataList(response.data.list)、this.xxxHorizontalListView.setDataList(response.data.list)、this.xxxViewPager.setDataList(response.data.list)
-    - vtype="listItemCard"、vtype="oneViewPagerContent"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，比如：
-      \`\`\`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 // 每页数量
-          }
-      }
-      ...
-      // 设置书籍列表数据
-      this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)
-      // 设置第1个item节点数据
-      this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl
-      this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title
-      this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author
-      ...
-      // 设置轮播数据
-      this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)
-      // 设置第1个item节点数据
-      this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl
-      this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title
-      ...
-      \`\`\`
-
-#### 10. 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。
-
-#### 11. 禁用以下6种代码写法
-- 1、禁止在函数里面定义内部函数，必须定义函数为全局函数
-  - ❌ 错误的写法：
-  \`\`\`typescript
-  private initView(): void {
-      const countCardData: number = () => {
-          // xxx代码
-      }
-      const count = countCardData()
-  }
-  \`\`\`
-  - ✅ 正确的写法是：
-  \`\`\`typescript
-  private initView(): void {
-      const count = this.countCardData()
-  }
-  private countCardData(): number {
-    // xxx代码
-  }
-  \`\`\`
-- 2、禁止使用for.in循环，必须使用fori循环的写法，那么就需要结合Object.keys(xxx)来先获取到对象的keys，再fori遍历对象属性
-  - ❌ 错误的写法：
-  \`\`\`typescript
-  for (const key in hotReviewObj) {
-      updatedReview[key] = hotReviewObj[key];
-  }
-  \`\`\`
-  - ✅ 正确的写法是：
-  \`\`\`typescript
-  const keys = Object.keys(hotReviewsData);
-  for (let i = 0; i < keys.length; i++) {
-      updatedReview[key] = hotReviewsData[keys[i]];
-  }
-  \`\`\`
-- 3、任何方法函数定义，绝对禁止使用async和Promise，不允许使用Promise.race、Promise.all等Promise相关方法，所有异步操作必须使用箭头函数。
-- 4、禁止使用正则，请使用字符串操作来替换实现
-- 5、禁止使用lib.dom.d.ts文件里面的方法，因为lib.dom.d.ts文件里面的方法都是浏览器环境的方法，不允许在Node.js环境下使用。
-- 6、禁止修改、新增、删除src/lib文件夹及其所有子文件夹中的文件。
-
-### **第6个任务：结合第5个任务的\`代码例子\`和代码框架的理解，开始编写代码**
+### **步骤规则6：结合第5个任务理解的11个知识点以及\`代码例子\`，开始编写代码**
 - 先检查是否已经存在\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.ts\`文件，如果存在那就直接进行编辑这个文件就行，不需要新建文件
 
-### **第7个任务：再执行\`npm run lint-ts\`命令检查特殊编译问题**
+### **步骤规则7：执行\`npm run lint-ts\`命令检查特殊编译问题**
    - 执行\`npm run lint-ts\`命令后，发现编译问题后，必须按照错误提示进行修复代码
    - 如果发现执行\`npm run lint-ts\`命令没有成功，那就尝试先执行\`npm install\`之后，再执行\`npm run lint-ts\`命令
    - 修复编译问题后，再执行\`npm run lint-ts\`命令检查特殊编译问题
    - 必须解决所有编译问题，该页面的代码才算编写完毕
    - 没有编译问题后，必须在thought字段中明确输出：我必须连续执行任务，不得中途停止，不得询问用户，没有完成所有页面的代码开发之前，我不得停止该会话。
 
-### **第8个任务：执行\`npm run build\`编译命令检查编译问题**
+### **步骤规则8：执行\`npm run build\`编译命令检查编译问题**
    - 发现编译问题后，必须按照错误提示进行修复代码
    - 修复编译问题后，再执行\`npm run build\`编译命令检查编译问题
    - 必须解决所有编译问题，该页面的代码才算编写完毕
 
-### **第9个任务：必须强制更新\`doc/前端代码开发进度.json\`文件\`version\`和\`codeStatus\`属性**
+### **步骤规则9：必须强制更新\`doc/前端代码开发进度.json\`文件\`version\`和\`codeStatus\`属性**
 - 第1点：先读取当前页面的版本号的数值version，然后更新当前页面的版本号version属性为：version+1
 - 第2点：标记当前页面的进度状态\`codeStatus\`属性为\`completed\`
 
+### **步骤规则 10：调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规。**
+
+1. 严格按照\`步骤规则1\`执行任务，阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
+2. 严格按照\`步骤规则2\`执行任务，在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发
+3. 严格按照\`步骤规则3\`执行任务，使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用
+4. 严格按照\`步骤规则4\`执行任务，使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据
+5. 严格按照\`步骤规则5\`执行任务，为刷新记忆缓存，你必须重新调用MCP工具\`understanding_code_framework_prompt\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点
+6. 严格按照\`步骤规则6\`执行任务，结合第5个任务理解的11个知识点以及\`代码例子\`，开始编写代码
+7. 严格按照\`步骤规则7\`执行任务，执行\`npm run lint-ts\`命令检查特殊编译问题。
+8. 严格按照\`步骤规则8\`执行任务，执行\`npm run build\`编译命令检查编译问题。
+9. 严格按照\`步骤规则9\`执行任务，必须强制更新\`doc/前端代码开发进度.json\`文件\`version\`和\`codeStatus\`属性
+10. 严格按照\`步骤规则10\`执行任务，调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规
 
 ## 代码例子
 - homePage.ts文件代码
@@ -413,4 +153,4 @@ export default class HomePageData {
 }
 \`\`\`
 `;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appCode.js","sourceRoot":"","sources":["../src/appCode.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ZjC,CAAC","sourcesContent":["export const codePromptTemplate = `# 你是typescript代码专家，根据用户输入的需求描述，严格遵守\\`代码规范\\`，参考\\`代码例子\\`，严格按照\\`编写代码的9 个步骤\\`完成代码开发\n\n## 代码规范\n- **代码注释使用中文**：代码的注释文字，必须要使用中文，不能使用其他语言\n- **结尾禁止分号**：一句代码的结尾禁止写分号，不需要写分号的\n- 如果是移动端开发式不需要考虑鼠标相关事情的，电脑端才需要考虑鼠标相关事情\n- 字符串要以单引号来写，如：'我的'。\n\n## 页面默认业务逻辑\n- **如用户没在描述中明确指明页面的业务逻辑，其中项目设计文档'.bytefun/{数字序号}-xxx功能模块业务逻辑设计.md'不算用户明确指定的业务逻辑，那各个页面的业务逻辑默认必须遵守以下固定逻辑并输出xxx页面默认遵守的固定逻辑，比如：闪屏页的逻辑：xxx等**\n  - 不存在权限请求页面，所有权限请求必须使用弹框的交互方式，而且是遵循\"即用即取\"（Just-in-Time）的原则\n  - 绝对不会有任何关于隐私协议/服务条款页的逻辑\n  - 闪屏页\n    - 如果有闪屏页，那么启动后第一个页面必须是闪屏页，闪屏页不会有跳到登录页的路径，只有跳到引导页或首页的路径\n    - 闪屏页不做任何业务逻辑，不请求任何网络接口，只需判断是否首次启动，如果首次启动就x秒后跳到引导页，如果不是首次启动就跳到首页\n    - ❌ 闪屏页绝对禁止做的事情：\n      - 请求任何网络接口\n      - 请求版本更新API接口\n      - 跳到隐私协议/服务条款页\n      - 弹出任何其他弹框\n      - 任何权限请求\n  - 引导页\n    = 引导页告页不会有跳到登录页的路径，只有跳到首页的路径\n    - 不会有任何网络请求、业务逻辑，引导页仅仅是一个展示静态数据的页面\n    - 不需要自动轮播\n    - 一般整个页面只有一个轮播组件、轮播指示器和底部一个按钮，底部按钮在非第一页时显示下一步，在最后一页时显示立即体验\n  - 首页\n    - 进入首页一般需要请求app版本更新API接口，判断是否需要更新，如果需要更新就弹出更新弹框，如果不需要那就不做任何事情\n    - 进入首页还要读取本地数据：全局配置数据。一般用于功能开关、ABTest配置等，读取完毕后，还要网络请求一次全局配置API，将全局配置数据更新到本地数据中\n    - 一般是有一个底部功能导航栏，点击底部功能导航栏的图标会切换到对应的tab页面，tab页面一般有多个，每个tab页面有不同的业务逻辑\n    - 如果用户输入的需求描述没有明确指定首页底部功能导航栏有哪些功能，那么你必须思考首页底部功能导航栏有哪些功能item项\n  - 登录页\n    - 登录页是用户点击需要登录才能访问的页面时，才会跳转到的页面，而不是从闪屏页判断是否需要登录然后跳进去\n\n## 调用 todo_write 工具创建编写代码的 9 个任务列表，必须按照以下 9 个任务创建任务列表，禁止跳过任何任务\n\n### **第1个任务：阅读\\`doc/前端代码开发进度.json\\`文件，得到当前页面所属的功能模块的英文名字\\`moduleNameEN\\`和当前要开发的页面的英文名字\\`pageNameEN\\`\n\n### **第2个任务：在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发2**\n\n### **第3个任务：使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用**\n\n### **第4个任务：使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据**\n\n### **第5个任务：必须先理解项目代码框架11个知识点**\n#### 1. **理解View组件的声明规则**\n  - 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的\n  - View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView\n  - 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件\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组件的选中状态、聚焦状态、禁用状态的变化都必须通过\\`setStation(station: ViewStation)\\`函数来设置，不能直接设置组件的UI属性，只需要设置组件的station属性即可自动更新组件的UI样式\n  - 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\\`visibility\\`属性进行设置，不得使用\\`station\\`属性。\n  - 所有View组件的normal、readOnly、focus、selected、disabled状态的设置都必须使用View的\\`station\\`属性进行设置。\n\n#### 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**\n  - 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法\n  - 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块\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  - 页面跳转必须使用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  - 所有Page的子类，都允许添加构造函数和构造函数的参数，这些参数就用来页面跳转时页面之间传递数据使用，比如：商品列表页ProjectListPage跳到商品详情页ProjectDetailPage，那么ProjectListPage应该要传给ProjectDetailPage一个参数：productID。所以，ProjectDetailPage的页面参数声明和构造函数应该是这样写：\n    private productID: string\n    constructor(productID: string) {\n      super()\n      this.productID = productID\n    }。\n  - 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现\n  - 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。\n  - 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。\n  - 所有的网络拦截的全局统一处理需要在Application中的onGlobalNetSuccessIntercept(联网成功后，后端业务正确与错误都会回调到这里，所以在这里可统一处理业务错误码)或onGlobalNetFailIntercept(网络不通，连接失败情况会回调到这里)里面处理。\n  - 页面内的网络请求业务处理不得写在Application的onGlobalNetSuccessIntercept里面。\n  - 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明\n  - 字符串不得直接进行boolean运算然后赋值给boolean类型的变量，需要在字符串前面添加两个非运算：!!。比如正确的写法：const isAdd = !!this.inputView.text && isNew\n  - 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。\n  - 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。\n  - 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。\n  - 移动端的ViewPager的canIndicatorClick属性默认设置为false的，除非用户明确说明需要激活指示器的点点击切换ViewPager。\n  - 每一个页面(如loginPage)建议在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面，页面文件夹下如果需要还可创建一个页面数据ts文件(如loginPageData.ts)，这样如loginPage负责业务逻辑和交互逻辑，如loginPageData负责数据声明定义、初始化与管理等。\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 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 interface apiFailInfo {\n        msg: string\n        code: number\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: apiFailInfo) => void\n        ): void { }\n\n    }\n    \\`\\`\\`\n  - API类的使用方式：先import API类，然后调用API类的request方法，比如：\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: apiFailInfo) => {\n      // 请求失败后的处理\n    })\n    ...\n\n#### 9. **理解调用后端api接口返回数据后与UI数据绑定**\n  - 在调用后端api接口返回数据后，需要根据vtype来做不同的数据绑定，比如：\n    - vtype=\"verticalListView\"、vtype=\"horizontalListView\"、vtype=\"viewPager\"类型的节点组件，需要使用setDataList方法来绑定数据，比如：\n      this.xxxVerticalListView.setDataList(response.data.list)、this.xxxHorizontalListView.setDataList(response.data.list)、this.xxxViewPager.setDataList(response.data.list)\n    - vtype=\"listItemCard\"、vtype=\"oneViewPagerContent\"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，比如：\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      // 设置书籍列表数据\n      this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)\n      // 设置第1个item节点数据\n      this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title\n      this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author\n      ...\n      // 设置轮播数据\n      this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)\n      // 设置第1个item节点数据\n      this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title\n      ...\n      \\`\\`\\`\n\n#### 10. 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。\n\n#### 11. 禁用以下6种代码写法\n- 1、禁止在函数里面定义内部函数，必须定义函数为全局函数\n  - ❌ 错误的写法：\n  \\`\\`\\`typescript\n  private initView(): void {\n      const countCardData: number = () => {\n          // xxx代码\n      }\n      const count = countCardData()\n  }\n  \\`\\`\\`\n  - ✅ 正确的写法是：\n  \\`\\`\\`typescript\n  private initView(): void {\n      const count = this.countCardData()\n  }\n  private countCardData(): number {\n    // xxx代码\n  }\n  \\`\\`\\`\n- 2、禁止使用for.in循环，必须使用fori循环的写法，那么就需要结合Object.keys(xxx)来先获取到对象的keys，再fori遍历对象属性\n  - ❌ 错误的写法：\n  \\`\\`\\`typescript\n  for (const key in hotReviewObj) {\n      updatedReview[key] = hotReviewObj[key];\n  }\n  \\`\\`\\`\n  - ✅ 正确的写法是：\n  \\`\\`\\`typescript\n  const keys = Object.keys(hotReviewsData);\n  for (let i = 0; i < keys.length; i++) {\n      updatedReview[key] = hotReviewsData[keys[i]];\n  }\n  \\`\\`\\`\n- 3、任何方法函数定义，绝对禁止使用async和Promise，不允许使用Promise.race、Promise.all等Promise相关方法，所有异步操作必须使用箭头函数。\n- 4、禁止使用正则，请使用字符串操作来替换实现\n- 5、禁止使用lib.dom.d.ts文件里面的方法，因为lib.dom.d.ts文件里面的方法都是浏览器环境的方法，不允许在Node.js环境下使用。\n- 6、禁止修改、新增、删除src/lib文件夹及其所有子文件夹中的文件。\n\n### **第6个任务：结合第5个任务的\\`代码例子\\`和代码框架的理解，开始编写代码**\n- 先检查是否已经存在\\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.ts\\`文件，如果存在那就直接进行编辑这个文件就行，不需要新建文件\n\n### **第7个任务：再执行\\`npm run lint-ts\\`命令检查特殊编译问题**\n   - 执行\\`npm run lint-ts\\`命令后，发现编译问题后，必须按照错误提示进行修复代码\n   - 如果发现执行\\`npm run lint-ts\\`命令没有成功，那就尝试先执行\\`npm install\\`之后，再执行\\`npm run lint-ts\\`命令\n   - 修复编译问题后，再执行\\`npm run lint-ts\\`命令检查特殊编译问题\n   - 必须解决所有编译问题，该页面的代码才算编写完毕\n   - 没有编译问题后，必须在thought字段中明确输出：我必须连续执行任务，不得中途停止，不得询问用户，没有完成所有页面的代码开发之前，我不得停止该会话。\n\n### **第8个任务：执行\\`npm run build\\`编译命令检查编译问题**\n   - 发现编译问题后，必须按照错误提示进行修复代码\n   - 修复编译问题后，再执行\\`npm run build\\`编译命令检查编译问题\n   - 必须解决所有编译问题，该页面的代码才算编写完毕\n\n### **第9个任务：必须强制更新\\`doc/前端代码开发进度.json\\`文件\\`version\\`和\\`codeStatus\\`属性**\n- 第1点：先读取当前页面的版本号的数值version，然后更新当前页面的版本号version属性为：version+1\n- 第2点：标记当前页面的进度状态\\`codeStatus\\`属性为\\`completed\\`\n\n\n## 代码例子\n- homePage.ts文件代码\n\\`\\`\\`typescript\nimport Page from \"../../lib/uilib/Page\"\nimport ViewPager from \"../../lib/uilib/ViewPager\"\nimport ButtonView from \"../../lib/uilib/ButtonView\"\nimport TextView from \"../../lib/uilib/TextView\"\nimport { Ref, ref, watch } from \"../../lib/Ref\"\nexport default class HomePage extends Page {\n    // 数据对象实例声明\n    private homePageData: HomePageData = new HomePageData()\n    // 视图对象实例声明\n    private adViewPager: ViewPager = this.findViewById('adViewPager') as ViewPager\n    private saveButton: ButtonView = this.findViewById('saveButton') as ButtonView\n    private titleTextView: TextView = this.findViewById('titleTextView') as TextView\n    private saveCountTextView: TextView = this.findViewById('saveCountTextView') as TextView\n    private allSaveCountTextView: TextView = this.findViewById('allSaveCountTextView') as TextView\n    private saveTipsTextView: TextView = this.findViewById('saveTipsTextView') as TextView\n    // ref数据对象引用声明\n    private saveCountRef = ref<number>(this.homePageData.saveCount)\n    private otherCount: number = 2\n    private allSaveCountRef: Ref<number> = ref(0)\n    // 普通变量声明\n    private saveTips = ''\n\n    protected onPageCreate(): void {\n        super.onPageCreate()\n        this.initData()\n        this.initView()\n    }\n\n    private initData(): void {\n        watch([this.saveCountRef, this.allSaveCountRef], () => {\n           let otherCount = 2\n           if (otherCount > 5) {\n            this.allSaveCountRef.value = this.homePageData.saveCount + 5\n           } else {\n            this.allSaveCountRef.value = this.homePageData.saveCount + 10\n           }\n           this.saveTipsTextView.text = this.saveCountRef.value > 5 ? '保存成功' : '保存失败'\n           this.allSaveCountTextView.text = this.allSaveCountRef.value + '个'\n        })\n    }\n\n    private initView(): void {\n        this.saveButton.setOnClickListener(() => {\n            this.saveCountRef.value++\n            this.homePageData.title = 'Home Page'\n            this.saveTipsTextView.text = this.saveTips\n            AllFunction.saveDatabaseNumber('saveCount', this.saveCountRef.value)\n            AllFunction.startPage(new BookInfoPage())\n        })\n    }\n\n}\n\\`\\`\\`\n\n- homePageData.ts文件代码\n\\`\\`\\` typescript\nexport default class HomePageData {\n    public title: string = ''\n    public saveCount: number = 0\n    public userInfo: BookInfo = new BookInfo()\n}\n\\`\\`\\`\n`;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appCode.js","sourceRoot":"","sources":["../src/appCode.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0JjC,CAAC","sourcesContent":["export const codePromptTemplate = `# 你是typescript代码专家，根据用户输入的需求描述，严格遵守\\`代码规范\\`，参考\\`代码例子\\`，严格按照\\`编写代码的10 个步骤\\`完成代码开发\n\n## 代码规范\n- **代码注释使用中文**：代码的注释文字，必须要使用中文，不能使用其他语言\n- **结尾禁止分号**：一句代码的结尾禁止写分号，不需要写分号的\n- 如果是移动端开发式不需要考虑鼠标相关事情的，电脑端才需要考虑鼠标相关事情\n- 字符串要以单引号来写，如：'我的'。\n\n## 页面默认业务逻辑\n- **如用户没在描述中明确指明页面的业务逻辑，其中项目设计文档'.bytefun/{数字序号}-xxx功能模块业务逻辑设计.md'不算用户明确指定的业务逻辑，那各个页面的业务逻辑默认必须遵守以下固定逻辑并输出xxx页面默认遵守的固定逻辑，比如：闪屏页的逻辑：xxx等**\n  - 不存在权限请求页面，所有权限请求必须使用弹框的交互方式，而且是遵循\"即用即取\"（Just-in-Time）的原则\n  - 绝对不会有任何关于隐私协议/服务条款页的逻辑\n  - 闪屏页\n    - 如果有闪屏页，那么启动后第一个页面必须是闪屏页，闪屏页不会有跳到登录页的路径，只有跳到引导页或首页的路径\n    - 闪屏页不做任何业务逻辑，不请求任何网络接口，只需判断是否首次启动，如果首次启动就x秒后跳到引导页，如果不是首次启动就跳到首页\n    - ❌ 闪屏页绝对禁止做的事情：\n      - 请求任何网络接口\n      - 请求版本更新API接口\n      - 跳到隐私协议/服务条款页\n      - 弹出任何其他弹框\n      - 任何权限请求\n  - 引导页\n    = 引导页告页不会有跳到登录页的路径，只有跳到首页的路径\n    - 不会有任何网络请求、业务逻辑，引导页仅仅是一个展示静态数据的页面\n    - 不需要自动轮播\n    - 一般整个页面只有一个轮播组件、轮播指示器和底部一个按钮，底部按钮在非第一页时显示下一步，在最后一页时显示立即体验\n  - 首页\n    - 进入首页一般需要请求app版本更新API接口，判断是否需要更新，如果需要更新就弹出更新弹框，如果不需要那就不做任何事情\n    - 进入首页还要读取本地数据：全局配置数据。一般用于功能开关、ABTest配置等，读取完毕后，还要网络请求一次全局配置API，将全局配置数据更新到本地数据中\n    - 一般是有一个底部功能导航栏，点击底部功能导航栏的图标会切换到对应的tab页面，tab页面一般有多个，每个tab页面有不同的业务逻辑\n    - 如果用户输入的需求描述没有明确指定首页底部功能导航栏有哪些功能，那么你必须思考首页底部功能导航栏有哪些功能item项\n  - 登录页\n    - 登录页是用户点击需要登录才能访问的页面时，才会跳转到的页面，而不是从闪屏页判断是否需要登录然后跳进去\n\n## **执行业务逻辑代码实现：每一个页面业务逻辑代码实现都必须调用 todo_write 工具创建以下 10 个任务列表，创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。**\n\n1. 严格按照\\`步骤规则1\\`执行任务，阅读\\`doc/前端代码开发进度.json\\`文件，得到当前页面所属的功能模块的英文名字\\`moduleNameEN\\`和当前要开发的页面的英文名字\\`pageNameEN\\`\n2. 严格按照\\`步骤规则2\\`执行任务，在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发\n3. 严格按照\\`步骤规则3\\`执行任务，使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用\n4. 严格按照\\`步骤规则4\\`执行任务，使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据\n5. 严格按照\\`步骤规则5\\`执行任务，为刷新记忆缓存，你必须重新调用MCP工具\\`understanding_code_framework_prompt\\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点\n6. 严格按照\\`步骤规则6\\`执行任务，结合第5个任务理解的11个知识点以及\\`代码例子\\`，开始编写代码\n7. 严格按照\\`步骤规则7\\`执行任务，执行\\`npm run lint-ts\\`命令检查特殊编译问题。\n8. 严格按照\\`步骤规则8\\`执行任务，执行\\`npm run build\\`编译命令检查编译问题。\n9. 严格按照\\`步骤规则9\\`执行任务，必须强制更新\\`doc/前端代码开发进度.json\\`文件\\`version\\`和\\`codeStatus\\`属性\n10. 严格按照\\`步骤规则10\\`执行任务，调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规\n\n### **步骤规则1：阅读\\`doc/前端代码开发进度.json\\`文件，得到当前页面所属的功能模块的英文名字\\`moduleNameEN\\`和当前要开发的页面的英文名字\\`pageNameEN\\`\n\n### **步骤规则2：在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发**\n\n### **步骤规则3：使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用**\n\n### **步骤规则4：使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据**\n\n### **步骤规则5：为刷新记忆缓存，你必须重新调用MCP工具\\`understanding_code_framework_prompt\\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点**\n\n### **步骤规则6：结合第5个任务理解的11个知识点以及\\`代码例子\\`，开始编写代码**\n- 先检查是否已经存在\\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.ts\\`文件，如果存在那就直接进行编辑这个文件就行，不需要新建文件\n\n### **步骤规则7：执行\\`npm run lint-ts\\`命令检查特殊编译问题**\n   - 执行\\`npm run lint-ts\\`命令后，发现编译问题后，必须按照错误提示进行修复代码\n   - 如果发现执行\\`npm run lint-ts\\`命令没有成功，那就尝试先执行\\`npm install\\`之后，再执行\\`npm run lint-ts\\`命令\n   - 修复编译问题后，再执行\\`npm run lint-ts\\`命令检查特殊编译问题\n   - 必须解决所有编译问题，该页面的代码才算编写完毕\n   - 没有编译问题后，必须在thought字段中明确输出：我必须连续执行任务，不得中途停止，不得询问用户，没有完成所有页面的代码开发之前，我不得停止该会话。\n\n### **步骤规则8：执行\\`npm run build\\`编译命令检查编译问题**\n   - 发现编译问题后，必须按照错误提示进行修复代码\n   - 修复编译问题后，再执行\\`npm run build\\`编译命令检查编译问题\n   - 必须解决所有编译问题，该页面的代码才算编写完毕\n\n### **步骤规则9：必须强制更新\\`doc/前端代码开发进度.json\\`文件\\`version\\`和\\`codeStatus\\`属性**\n- 第1点：先读取当前页面的版本号的数值version，然后更新当前页面的版本号version属性为：version+1\n- 第2点：标记当前页面的进度状态\\`codeStatus\\`属性为\\`completed\\`\n\n### **步骤规则 10：调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规。**\n\n1. 严格按照\\`步骤规则1\\`执行任务，阅读\\`doc/前端代码开发进度.json\\`文件，得到当前页面所属的功能模块的英文名字\\`moduleNameEN\\`和当前要开发的页面的英文名字\\`pageNameEN\\`\n2. 严格按照\\`步骤规则2\\`执行任务，在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md，必须完整阅读该设计文档，严格按照设计文档说明进行代码开发\n3. 严格按照\\`步骤规则3\\`执行任务，使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素，绝对不能凭想象或假设添加不存在的元素引用\n4. 严格按照\\`步骤规则4\\`执行任务，使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径，编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据\n5. 严格按照\\`步骤规则5\\`执行任务，为刷新记忆缓存，你必须重新调用MCP工具\\`understanding_code_framework_prompt\\`，然后必须仔细全面理解工具返回的项目代码框架11个知识点\n6. 严格按照\\`步骤规则6\\`执行任务，结合第5个任务理解的11个知识点以及\\`代码例子\\`，开始编写代码\n7. 严格按照\\`步骤规则7\\`执行任务，执行\\`npm run lint-ts\\`命令检查特殊编译问题。\n8. 严格按照\\`步骤规则8\\`执行任务，执行\\`npm run build\\`编译命令检查编译问题。\n9. 严格按照\\`步骤规则9\\`执行任务，必须强制更新\\`doc/前端代码开发进度.json\\`文件\\`version\\`和\\`codeStatus\\`属性\n10. 严格按照\\`步骤规则10\\`执行任务，调用 todo_write 工具为下一个页面创建以下 10 个任务列表并马上执行，确保流程永续，如果还没有完成该功能模块的所有页面设计，不得停止结束任务，如果你直接编写下一个页面业务逻辑代码，马上报错，视为严重违规。创建完成后必须确认：如果任务数量不是 10 个，立即报错并重新创建。如果你在该功能模块的所有页面还没有开发业务逻辑完毕的情况下停止了任务，马上报错，视为严重违规\n\n## 代码例子\n- homePage.ts文件代码\n\\`\\`\\`typescript\nimport Page from \"../../lib/uilib/Page\"\nimport ViewPager from \"../../lib/uilib/ViewPager\"\nimport ButtonView from \"../../lib/uilib/ButtonView\"\nimport TextView from \"../../lib/uilib/TextView\"\nimport { Ref, ref, watch } from \"../../lib/Ref\"\nexport default class HomePage extends Page {\n    // 数据对象实例声明\n    private homePageData: HomePageData = new HomePageData()\n    // 视图对象实例声明\n    private adViewPager: ViewPager = this.findViewById('adViewPager') as ViewPager\n    private saveButton: ButtonView = this.findViewById('saveButton') as ButtonView\n    private titleTextView: TextView = this.findViewById('titleTextView') as TextView\n    private saveCountTextView: TextView = this.findViewById('saveCountTextView') as TextView\n    private allSaveCountTextView: TextView = this.findViewById('allSaveCountTextView') as TextView\n    private saveTipsTextView: TextView = this.findViewById('saveTipsTextView') as TextView\n    // ref数据对象引用声明\n    private saveCountRef = ref<number>(this.homePageData.saveCount)\n    private otherCount: number = 2\n    private allSaveCountRef: Ref<number> = ref(0)\n    // 普通变量声明\n    private saveTips = ''\n\n    protected onPageCreate(): void {\n        super.onPageCreate()\n        this.initData()\n        this.initView()\n    }\n\n    private initData(): void {\n        watch([this.saveCountRef, this.allSaveCountRef], () => {\n           let otherCount = 2\n           if (otherCount > 5) {\n            this.allSaveCountRef.value = this.homePageData.saveCount + 5\n           } else {\n            this.allSaveCountRef.value = this.homePageData.saveCount + 10\n           }\n           this.saveTipsTextView.text = this.saveCountRef.value > 5 ? '保存成功' : '保存失败'\n           this.allSaveCountTextView.text = this.allSaveCountRef.value + '个'\n        })\n    }\n\n    private initView(): void {\n        this.saveButton.setOnClickListener(() => {\n            this.saveCountRef.value++\n            this.homePageData.title = 'Home Page'\n            this.saveTipsTextView.text = this.saveTips\n            AllFunction.saveDatabaseNumber('saveCount', this.saveCountRef.value)\n            AllFunction.startPage(new BookInfoPage())\n        })\n    }\n\n}\n\\`\\`\\`\n\n- homePageData.ts文件代码\n\\`\\`\\` typescript\nexport default class HomePageData {\n    public title: string = ''\n    public saveCount: number = 0\n    public userInfo: BookInfo = new BookInfo()\n}\n\\`\\`\\`\n`;\n"]}

package/build/appCodeRule.d.ts

@@ -0,0 +1,2 @@
+export declare const understandingCodeFrameworkTemplate = "\n# **\u5FC5\u987B\u5148\u7406\u89E3\u9879\u76EE\u4EE3\u7801\u6846\u67B611\u4E2A\u77E5\u8BC6\u70B9**\n## 1. **\u7406\u89E3View\u7EC4\u4EF6\u7684\u58F0\u660E\u89C4\u5219**\n  - \u8FD9\u4E0D\u662Fhtml\u3001react\u7B49\u5F00\u53D1\uFF0C\u8FD9\u662F\u4E00\u4E2A\u65B0\u7684\u5F00\u53D1\u6846\u67B6\uFF0C\u662F\u57FA\u4E8Esrc/lib/uilib\u6587\u4EF6\u5939\u91CC\u9762\u7684UI\u7EC4\u4EF6\u5E93\u6765\u5F00\u53D1\u7684\n  - View\u7EC4\u4EF6\u7684\u57FA\u7C7B\u662FBaseView\uFF0C\u5BB9\u5668\u57FA\u7C7B\u662FBaseContainerView\uFF0C\u6240\u6709View\u7EC4\u4EF6\u90FD\u7EE7\u627F\u81EABaseView\n  - \u67E5\u770B'src/lib/uilib/'\u6587\u4EF6\u5939\u4E0B\u9762\u7684\u6587\u4EF6\u540D\u5B57\uFF0C\u7406\u89E3\u603B\u5171\u6709\u591A\u5C11\u79CDUI\u7EC4\u4EF6\n  - View\u7EC4\u4EF6\u7684\u58F0\u660E\u5FC5\u987B\u5728\u7C7B\u6587\u4EF6\u5F00\u59CB\u65F6\u5148\u58F0\u660E\uFF0C\u5E76\u4E14\u5FC5\u987B\u8981\u58F0\u660E\u5177\u4F53\u7684View\u7EC4\u4EF6\u7C7B\u578B\uFF0C\u4E0D\u5F97\u58F0\u660E\u4E3ABaseView\uFF0C\u4E0D\u5F97\u5728\u4EFB\u4F55\u51FD\u6570\u4F53\u91CC\u9762\u901A\u8FC7findViewById\u6765\u58F0\u660EView\u7EC4\u4EF6\uFF0C\u6BD4\u5982\uFF1A\n    - \u2705 \u6B63\u786E\u7684\u5199\u6CD5\uFF1A\n    ```typescript\n    public class HomePage extends Page {\n      private nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    ```\n    - \u274C \u9519\u8BEF\u7684\u5199\u6CD5\uFF08\u6CA1\u6709\u58F0\u5177\u4F53\u7684View\u7EC4\u4EF6\u7C7B\u578B\uFF09\uFF1A\n    ```typescript\n    private nameTextView = this.findViewById('nameTextView')\n    ```\n    - \u274C \u9519\u8BEF\u7684\u5199\u6CD5\uFF08\u5728\u51FD\u6570\u4F53\u91CC\u9762\u901A\u8FC7findViewById\u6765\u58F0\u660EView\u7EC4\u4EF6\uFF09\uFF1A\n    ```typescript\n    private oneFunction() {\n      const nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    ```\n  - \u6240\u6709View\u7EC4\u4EF6\u7684\u9009\u4E2D\u72B6\u6001\u3001\u805A\u7126\u72B6\u6001\u3001\u7981\u7528\u72B6\u6001\u7684\u53D8\u5316\u90FD\u5FC5\u987B\u901A\u8FC7`setStation(station: ViewStation)`\u51FD\u6570\u6765\u8BBE\u7F6E\uFF0C\u4E0D\u80FD\u76F4\u63A5\u8BBE\u7F6E\u7EC4\u4EF6\u7684UI\u5C5E\u6027\uFF0C\u53EA\u9700\u8981\u8BBE\u7F6E\u7EC4\u4EF6\u7684station\u5C5E\u6027\u5373\u53EF\u81EA\u52A8\u66F4\u65B0\u7EC4\u4EF6\u7684UI\u6837\u5F0F\n  - \u6240\u6709View\u7EC4\u4EF6\u7684\u663E\u793A\u3001\u9690\u85CF\u5360\u4F4D\u3001\u9690\u85CF\u4E0D\u5360\u4F4D\u7684\u8BBE\u7F6E\u90FD\u5FC5\u987B\u4F7F\u7528View\u7684`visibility`\u5C5E\u6027\u8FDB\u884C\u8BBE\u7F6E\uFF0C\u4E0D\u5F97\u4F7F\u7528`station`\u5C5E\u6027\u3002\n  - \u6240\u6709View\u7EC4\u4EF6\u7684normal\u3001readOnly\u3001focus\u3001selected\u3001disabled\u72B6\u6001\u7684\u8BBE\u7F6E\u90FD\u5FC5\u987B\u4F7F\u7528View\u7684`station`\u5C5E\u6027\u8FDB\u884C\u8BBE\u7F6E\u3002\n\n## 2. **\u7406\u89E3\u552F\u4E00\u7684\u80FD\u529B\u65B9\u6CD5AllFunction.ts\u4EE5\u53CAjson\u76F8\u5173\u4EE3\u7801**\n  - \u4F7F\u7528'read_file'\u5DE5\u5177\u9605\u8BFB\u5E76\u7406\u89E3'src/lib/AllFunction.ts'\u6587\u4EF6\uFF0C\u7406\u89E3\u8BE5\u5DE5\u7A0B\u80FD\u4F7F\u7528\u7684\u552F\u4E00\u7684\u80FD\u529B\u65B9\u6CD5\n  - \u8BF7\u4E25\u683C\u6309\u7167\u552F\u4E00\u7684\u80FD\u529B\u65B9\u6CD5AllFunction.ts\uFF0C\u4E0D\u8981\u65B0\u589E\u3001\u5220\u9664\u6216\u4FEE\u6539\u4EFB\u4F55AllFunction\u63A5\u53E3\u58F0\u660E\uFF1B\u4E5F\u4E0D\u8981\u8C03\u7528\u5176\u4ED6\u672A\u5728AllFunction\u4E2D\u51FA\u73B0\u7684\u51FD\u6570\u6216\u6A21\u5757\n  \n## 3. **\u7406\u89E3Ref\u3001watch**\n  - Ref\u7684\u6570\u636E\u7C7B\u578B\u53EA\u80FD\u662F\u4EE5\u4E0B5\u4E2D\u7C7B\u578B\uFF1A\u6570\u5B57\u4F7F\u7528Ref<number>\uFF0C\u5B57\u7B26\u4E32\u4F7F\u7528Ref<string>\uFF0C\u5E03\u5C14\u91CF\u4F7F\u7528Ref<boolean>\uFF0C\u5BF9\u8C61\u4F7F\u7528Ref<any>\uFF0C\u6570\u7EC4\u4F7F\u7528Ref<Array<any>>\u6216Ref<Array<any> | null>\u6216Ref<any[]>\u6216Ref<any[] | null>\u3002\n  - \u4F7F\u7528'read_file'\u5DE5\u5177\u9605\u8BFB\u5E76\u7406\u89E3'src/lib/Ref.ts'\u6587\u4EF6\uFF0C\u7406\u89E3Ref\u548Cwatch\u7684\u5B9A\u4E49\u7528\u6CD5\n  - watch\u662F\u76D1\u542CRef\u7684\u53D8\u5316\uFF0C\u7136\u540E\u505A\u76F8\u5173UI\u66F4\u65B0\u6216\u5176\u4ED6\u4E1A\u52A1\u903B\u8F91\uFF0C\u7B2C\u4E00\u4E2A\u53C2\u6570\u662F\u76D1\u542C\u7684Ref\u6570\u7EC4\uFF0C\u7B2C\u4E8C\u4E2A\u53C2\u6570\u662F\u76D1\u542C\u7684\u56DE\u8C03\u51FD\u6570\uFF0C\u56DE\u8C03\u51FD\u6570\u4E2D\u53EF\u4EE5\u505A\u76F8\u5173UI\u66F4\u65B0\u6216\u5176\u4ED6\u4E1A\u52A1\u903B\u8F91\u3002\n  - Ref\u662F\u54CD\u5E94\u5F0F\u6570\u636E\u6E90\uFF0Cwatch\u662F\u76D1\u542CRef\u7684\u53D8\u5316\uFF0C\u7136\u540E\u505A\u76F8\u5173UI\u66F4\u65B0\u6216\u5176\u4ED6\u4E1A\u52A1\u903B\u8F91\uFF0C\u6BD4\u5982\uFF1A\n  ```typescript\n  private nameTextRef: Ref<string> = ref('')\n  private otherCountRef: Ref<number> = ref(0)\n  watch([this.nameTextRef, this.otherCountRef], () => {\n    // \u53EF\u4EE5\u5148\u76F8\u5173\u7684UI\u66F4\u65B0\u6216\u4E1A\u52A1\u903B\u8F91\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`\u91CC\u9762\u7684`watch`\u51FD\u6570\uFF0C\u7B2C\u4E00\u4E2A\u5165\u53C2`refs: Ref<T>[]`\u7EDD\u5BF9\u7981\u6B62\u5148\u58F0\u660E\u5C40ref\u6570\u7EC4\u90E8\u53D8\u91CF\u518D\u4F20\u5165\uFF0C\u6B63\u786E\u7684\u5199\u6CD5\u5E94\u8BE5\u662F\u76F4\u63A5\u5199\u6570\u7EC4\uFF1A`[ref1, ref2]`\u5C31\u884C\n  - \u274C \u9519\u8BEF\u7684\u5199\u6CD5\uFF1A\n    ``` typescript\n    const refArray = [ref1, ref2]\n    watch(refArray, (newValues: T[]) => {\n        // \u76D1\u542Cref1\u548Cref2\u7684\u53D8\u5316\n    })\n    ```\n  - \u2705 \u6B63\u786E\u7684\u5199\u6CD5\uFF1A\n    ``` typescript\n    watch([ref1, ref2], (newValues: T[]) => {\n        // \u76D1\u542Cref1\u548Cref2\u7684\u53D8\u5316\n    })\n    ```\n\n## 4. **\u7406\u89E3setDataList\u65B9\u6CD5\u7684\u9759\u6001\u6570\u636E\u4E0E\u52A8\u6001\u6570\u636E\u573A\u666F**\n  - \u5BF9\u4E8E\u52A8\u6001\u6570\u636E\u5BB9\u5668ViewPager\u3001ListView\u7684setDataList\u65B9\u6CD5\uFF0C\u5982\u679C\u6570\u636E\u662F\u52A8\u6001\u7684\uFF0C\u6BD4\u5982\uFF1A\u4ECE\u540E\u7AEF\u63A5\u53E3\u83B7\u53D6\u7684\uFF0C\u624D\u80FD\u4F7F\u7528setDataList\u65B9\u6CD5\u6765\u8BBE\u7F6E\u6570\u636E\u3002\u9759\u6001\u6570\u636E\u5DF2\u7ECF\u5728UI\u9875\u9762\u4E0A\u5199\u597D\u4E86\uFF0C\u4F60\u4E0D\u5F97\u4F7F\u7528setDataList\u65B9\u6CD5\u6765\u8BBE\u7F6E\u6570\u636E\u3002\n  - \u5224\u65AD\u6807\u51C6\uFF1A\u5982\u679CUI\u9875\u9762\u4E2D\u5DF2\u7ECF\u6709\u5B8C\u6574\u7684\u8F6E\u64AD\u9879\u76EE/\u5217\u8868\u9879\u76EE\uFF0C\u5C31\u662F\u9759\u6001\u6570\u636E\uFF0C\u5982\u679C\u662F\u7F51\u7EDCAPI\u8FD4\u56DE\u7684\u6570\u636E\u5217\u8868\u5C31\u662F\u52A8\u6001\u6570\u636E\u3002\n  - \u2705 \u9759\u6001\u6570\u636E\u5BB9\u5668\uFF08UI\u9875\u9762\u4E2D\u5DF2\u5199\u597D\u5185\u5BB9\uFF09\uFF1A\u4E0D\u4F7F\u7528setDataList()\n  - \u2705 \u52A8\u6001\u6570\u636E\u5BB9\u5668\uFF08\u9700\u8981\u4ECEAPI\u83B7\u53D6\uFF09\uFF1A\u624D\u4F7F\u7528setDataList()\n\n## 5. **View\u7EC4\u4EF6\uFF0C\u7406\u89E3\u6BCF\u4E2A\u7EC4\u4EF6\u53EF\u80FD\u91CC\u9762\u5DF2\u7ECF\u6709\u4E86\u54CD\u5E94\u5F0F\u6570\u636E\u6E90\uFF0C\u5982\u679C\u7EC4\u4EF6\u91CC\u9762\u5DF2\u7ECF\u6709\u4E86\u54CD\u5E94\u5F0F\u6570\u636E\u6E90\uFF0C\u90A3\u4E48\u4F60\u4E0D\u5F97\u518D\u81EA\u5DF1\u521B\u5EFAref\u53D8\u91CF\u6216\u8005\u4F7F\u7528onSelectChange\u7B49\u56DE\u8C03\u89E6\u53D1UI\u66F4\u65B0**\n  - \u4F8B\u5B50\uFF1AViewPager\u7684currentSelectIndex\u548CcurrentSelectIndexRef\u5C5E\u6027\u5DF2\u7ECF\u662F\u54CD\u5E94\u5F0F\u6570\u636E\u6E90\uFF0C\u53EF\u4EE5\u76F4\u63A5\u4F7F\u7528currentSelectIndexRef\u6765\u7ED1\u5B9A\u81EA\u52A8\u66F4\u65B0UI\u3002\n    public initView() {\n      this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length\n    }\n  - \u4F8B\u5B50\uFF1AViewPager\u7684currentSelectIndex\u548CcurrentSelectIndexRef\u5C5E\u6027\u5DF2\u7ECF\u662F\u54CD\u5E94\u5F0F\u6570\u636E\u6E90\uFF0C\u53EF\u4EE5\u76F4\u63A5\u4F7F\u7528currentSelectIndexRef\u6765\u7ED1\u5B9A\u81EA\u52A8\u66F4\u65B0UI\uFF0C\u6BD4\u5982\uFF1A\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\u7EC4\u4EF6\u548C\u8F6E\u64AD\u7EC4\u4EF6\u7684\u9009\u62E9\u53D8\u5316\u76D1\u542C\uFF0C\u5FC5\u987B\u4F7F\u7528`ViewPager`\u6216`TabContainer`\u7684`onSelectChange(func: (item: any, position: number) => void)`\u51FD\u6570\u6765\u76D1\u542C\u9009\u62E9\u53D8\u5316\n\n## 6. **\u7406\u89E3\u9875\u9762\u8DF3\u8F6C**\n  - \u9875\u9762\u8DF3\u8F6C\u5FC5\u987B\u4F7F\u7528AllFunction.startPage\u5B9E\u73B0\uFF0CstartPage\u4F20\u5165Page\u7684\u5B50\u7C7B\u5BF9\u8C61\uFF0C\u5982\uFF1AAllFunction.startPage(new ProductPage(this.productID))\u3002\n  - \u274C \u9875\u9762\u8DF3\u8F6C\u4E0D\u9700\u8003\u8651\u6A21\u5757\u5316\u3001\u5FAA\u73AF\u4F9D\u8D56\u3001\u6E10\u8FDB\u5F0F\u5F00\u53D1\uFF0C\u7EDD\u5BF9\u7981\u6B62\u5C4F\u853D\u9875\u9762\u8DF3\u8F6C\u7684\u4EE3\u7801\uFF0C\u6240\u6709\u9875\u9762\u90FD\u5DF2\u7ECF\u5B58\u5728\uFF0C\u4E0D\u4F1A\u51FA\u73B0\u7F16\u8BD1\u51FA\u9519\u7684\uFF0C\u5FC5\u987B\u660E\u786E\u5199\u4E0A\u9875\u9762\u8DF3\u8F6C\u7684\u4EE3\u7801\u548C\u76EE\u6807\u9875\u9762\u6240\u9700\u7684\u8DF3\u8F6C\u53C2\u6570\u3002\n  - \u5728Application.ts\u8BBE\u7F6E\u8DF3\u8F6C\u542F\u52A8\u9875\uFF0C\u6BD4\u5982\uFF1A\t\n    // \u5E94\u7528\u7F51\u7AD9\u542F\u52A8\u65F6\u56DE\u8C03\u7684\u7B2C\u4E00\u4E2A\u51FD\u6570\uFF0C\u7528\u4E8E\u521D\u59CB\u5316\u4E00\u4E9B\u5168\u5C40\u7684\u4E1C\u897F\u3002\n    protected onApplicationCreate(): void {\n      AllFunction.startPage(new SplashPage())\n    }\n  - \u2705 \u5F15\u5165\u5176\u4ED6\u7C7B\u53EA\u5141\u8BB8\u4E00\u79CD\u5199\u6CD5\uFF1A\u5728\u7C7B\u6587\u4EF6\u9876\u90E8\u8FDB\u884Cimport\uFF1Aimport GuidePage from '../guidePage/guidePage'\u3002\n  - \u274C \u7EDD\u5BF9\u7981\u6B62\u4F7F\u7528\u52A8\u6001import\u7684\u5199\u6CD5\uFF0C\u7A0B\u5E8F\u5E95\u5C42\u5DF2\u7ECF\u5904\u7406\u597D\u5FAA\u73AF\u4F9D\u8D56\u95EE\u9898\u4E86\uFF0C\u4F60\u4E0D\u9700\u8981\u8003\u8651\uFF0C\u6BD4\u5982\u7EDD\u5BF9\u7981\u6B62\u4EE5\u4E0B\u5199\u6CD5\uFF1A\n        // \u4F7F\u7528\u52A8\u6001\u5BFC\u5165\u907F\u514D\u5FAA\u73AF\u4F9D\u8D56\n        import('../guidePage/guidePage').then(({ default: GuidePage }) => {\n            AllFunction.startPage(new GuidePage())\n        })\n  - \u274C \u7EDD\u5BF9\u7981\u6B62\u4F7F\u7528require\u7684\u5199\u6CD5\uFF0C\u7A0B\u5E8F\u5E95\u5C42\u5DF2\u7ECF\u5904\u7406\u597D\u5FAA\u73AF\u4F9D\u8D56\u95EE\u9898\u4E86\uFF0C\u4F60\u4E0D\u9700\u8981\u8003\u8651\uFF0C\u6BD4\u5982\u7EDD\u5BF9\u7981\u6B62\u4EE5\u4E0B\u5199\u6CD5\uFF1A\n        require('../guidePage/guidePage').default\n  - \u2705 \u6B63\u786E\u7684\u5199\u6CD5\u662F\uFF1AAllFunction.startPage(new GuidePage())\u3002\u7136\u540E\u5728\u7C7B\u6587\u4EF6\u9876\u90E8\u8FDB\u884Cimport\uFF1Aimport GuidePage from '../guidePage/guidePage'\u3002\n  - \u5982\u679C\u9875\u9762\u8DF3\u8F6C\u9700\u8981\u4F20\u9012\u53C2\u6570\uFF0C\u90A3\u4E48\u9700\u8981\u4F7F\u7528Page\u7684\u5B50\u7C7B\u6784\u9020\u51FD\u6570\u6765\u4F20\u9012\u53C2\u6570\uFF0C\u6BD4\u5982\uFF1AAllFunction.startPage(new GuidePage(this.productID))\u3002\n  - \u5728\u5B9E\u73B0\u9875\u9762\u8DF3\u8F6C\u4EE3\u7801\u7684\u65F6\u5019\uFF0C\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0B\u4E09\u6B65\u6765\u5B9E\u73B0\uFF1A\n      - **\u7B2C\u4E00\u6B65\uFF1A\u5148\u5206\u6790\u8DF3\u8F6C\u7684\u76EE\u6807\u9875\u9762\u9700\u8981\u4F20\u9012\u54EA\u4E9B\u53C2\u6570**\n      - **\u7B2C\u4E8C\u6B65\uFF1A\u4FEE\u6539\u76EE\u6807\u9875\u9762\u6784\u9020\u51FD\u6570**\uFF1A\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      - **\u7B2C\u4E09\u6B65\uFF1A\u4FEE\u6539\u8DF3\u8F6C\u4EE3\u7801**\n      ```typescript\n      const bookData = this.readingHistoryDataRef.value[0]\n      AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))\n      ```\n\n## 7. **\u7406\u89E3\u57FA\u7840\u5F00\u53D1\u89C4\u5219**\n  - lib\u6587\u4EF6\u5939\u91CC\u9762\u7684\u4EE3\u7801\u6587\u4EF6\u90FD\u662F\u5185\u7F6E\u6846\u67B6\u4EE3\u7801\uFF0C\u7EDD\u5BF9\u7981\u6B62\u5BF9lib\u6587\u4EF6\u5939\u7684\u4EE3\u7801\u8FDB\u884C\u589E\u5220\u6539\u64CD\u4F5C\n  - \u6240\u6709Page\u7684\u5B50\u7C7B\uFF0C\u90FD\u5141\u8BB8\u6DFB\u52A0\u6784\u9020\u51FD\u6570\u548C\u6784\u9020\u51FD\u6570\u7684\u53C2\u6570\uFF0C\u8FD9\u4E9B\u53C2\u6570\u5C31\u7528\u6765\u9875\u9762\u8DF3\u8F6C\u65F6\u9875\u9762\u4E4B\u95F4\u4F20\u9012\u6570\u636E\u4F7F\u7528\uFF0C\u6BD4\u5982\uFF1A\u5546\u54C1\u5217\u8868\u9875ProjectListPage\u8DF3\u5230\u5546\u54C1\u8BE6\u60C5\u9875ProjectDetailPage\uFF0C\u90A3\u4E48ProjectListPage\u5E94\u8BE5\u8981\u4F20\u7ED9ProjectDetailPage\u4E00\u4E2A\u53C2\u6570\uFF1AproductID\u3002\u6240\u4EE5\uFF0CProjectDetailPage\u7684\u9875\u9762\u53C2\u6570\u58F0\u660E\u548C\u6784\u9020\u51FD\u6570\u5E94\u8BE5\u662F\u8FD9\u6837\u5199\uFF1A\n    private productID: string\n    constructor(productID: string) {\n      super()\n      this.productID = productID\n    }\u3002\n  - \u4EFB\u4F55\u9875\u9762\uFF08\u7279\u522B\u662F\u95EA\u5C4F\u9875\uFF09\u7684\u4E1A\u52A1\u903B\u8F91\u7EDD\u5BF9\u4E0D\u80FD\u653E\u5230Application.ts\u8FDB\u884C\u5904\u7406\uFF0CApplication.ts\u53EA\u8FDB\u884C\u5168\u5C40\u7F51\u7EDC\u62E6\u622A\u5904\u7406\u3001\u5168\u5C40\u9759\u6001\u53D8\u91CF\u3001\u5168\u5C40\u9759\u6001\u65B9\u6CD5\u7684\u5B9A\u4E49\u548C\u5B9E\u73B0\n  - \u5982\u679C\u662F\u591A\u4E2A\u9875\u9762\u5171\u7528\u7684\u6570\u636E\u53D8\u91CF\uFF0C\u53EF\u4EE5\u8003\u8651\u58F0\u660E\u4E3A\u5168\u5C40\u9759\u6001\u53D8\u91CF\uFF0C\u5E76\u5728Application.ts\u4E2D\u8FDB\u884C\u58F0\u660E\u3002\n  - \u5168\u5C40\u9759\u6001\u53D8\u91CF\u5728\u5173\u95EDAPP\u6216\u8005\u7F51\u9875\u540E\u4F1A\u6E05\u7406\u6389\u7684\uFF0C\u6240\u4EE5\u4F60\u8981\u601D\u8003\u6E05\u695A\u54EA\u4E9B\u6570\u636E\u53D8\u91CF\u9700\u8981\u6301\u4E45\u5316\u50A8\u5B58\uFF0C\u54EA\u4E9B\u662F\u5168\u5C40\u9759\u6001\u53D8\u91CF\uFF0C\u6301\u4E45\u5316\u63A5\u53E3\uFF1AsaveDatabaseXxx\u548CgetDatabaseDataXxx\uFF0C\u6BD4\u5982\u662F\u5426\u5DF2\u7ECF\u5F39\u51FA\u8FC7\u5E7F\u544A\u5F39\u6846\uFF0C\u8FD9\u4E2A\u5E94\u8BE5\u6301\u4E45\u5316\u50A8\u5B58\u3002\n  - \u6240\u6709\u7684\u7F51\u7EDC\u62E6\u622A\u7684\u5168\u5C40\u7EDF\u4E00\u5904\u7406\u9700\u8981\u5728Application\u4E2D\u7684onGlobalNetSuccessIntercept(\u8054\u7F51\u6210\u529F\u540E\uFF0C\u540E\u7AEF\u4E1A\u52A1\u6B63\u786E\u4E0E\u9519\u8BEF\u90FD\u4F1A\u56DE\u8C03\u5230\u8FD9\u91CC\uFF0C\u6240\u4EE5\u5728\u8FD9\u91CC\u53EF\u7EDF\u4E00\u5904\u7406\u4E1A\u52A1\u9519\u8BEF\u7801)\u6216onGlobalNetFailIntercept(\u7F51\u7EDC\u4E0D\u901A\uFF0C\u8FDE\u63A5\u5931\u8D25\u60C5\u51B5\u4F1A\u56DE\u8C03\u5230\u8FD9\u91CC)\u91CC\u9762\u5904\u7406\u3002\n  - \u9875\u9762\u5185\u7684\u7F51\u7EDC\u8BF7\u6C42\u4E1A\u52A1\u5904\u7406\u4E0D\u5F97\u5199\u5728Application\u7684onGlobalNetSuccessIntercept\u91CC\u9762\u3002\n  - \u58F0\u660E\u5168\u5C40\u53D8\u91CF\u3001\u5C40\u90E8\u53D8\u91CF\u5FC5\u987B\u8981\u58F0\u660E\u6570\u636E\u7C7B\u578B\uFF0C\u5E76\u4E14\u7EDD\u5BF9\u7981\u6B62\u4F7F\u7528any\uFF0C\u8BF7\u4F7F\u7528\u5177\u4F53\u7C7B\u578B\u6765\u58F0\u660E\n  - \u5B57\u7B26\u4E32\u4E0D\u5F97\u76F4\u63A5\u8FDB\u884Cboolean\u8FD0\u7B97\u7136\u540E\u8D4B\u503C\u7ED9boolean\u7C7B\u578B\u7684\u53D8\u91CF\uFF0C\u9700\u8981\u5728\u5B57\u7B26\u4E32\u524D\u9762\u6DFB\u52A0\u4E24\u4E2A\u975E\u8FD0\u7B97\uFF1A!!\u3002\u6BD4\u5982\u6B63\u786E\u7684\u5199\u6CD5\uFF1Aconst isAdd = !!this.inputView.text && isNew\n  - \u6240\u6709\u7684toast\u63D0\u793A\uFF0C\u5FC5\u987B\u8C03\u7528AllFunction.showToast\u65B9\u6CD5\u6765\u663E\u793A\uFF0C\u5E76\u4E14\u5982\u7528\u6237\u63CF\u8FF0\u6CA1\u6709\u660E\u786E\u8BF4\u660E\u9700\u8981toast\u63D0\u793A\uFF0C\u4F60\u4E0D\u5F97\u64C5\u81EA\u8FDB\u884CToast\u63D0\u793A\u3002\n  - \u5EF6\u65F6\u6267\u884CAllFunction.setTimeout\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u6E05\u7406timeout\uFF0C\u4EE3\u7801\u4E0A\u7EDD\u5BF9\u4E0D\u80FD\u8FDB\u884CcleaTimeout\u7B49\u7C7B\u4F3C\u64CD\u4F5C\uFF0C\u56E0\u6B64setTimeout\u4E5F\u4E0D\u9700\u8981\u58F0\u660E\u53D8\u91CF\u53BB\u63A5\u6536setTimeout\u8FD4\u56DE\u7684\u5F15\u7528\u3002\n  - \u8F6E\u64ADViewPager\u5BF9\u5E94\u7684\u7D22\u5F15\u6307\u793A\u5668\u5BB9\u5668\uFF0C\u8FD9\u4E2A\u7D22\u5F15\u6307\u793A\u5668\u4E0D\u9700\u8981\u989D\u5916\u4EE3\u7801\u5B9E\u73B0\u6307\u793A\u5668\u70B9\u7684\u5207\u6362UI\u66F4\u65B0\u903B\u8F91\uFF0C\u672C\u8EABViewPager\u4E0EIndicatorContainer\u5E95\u5C42\u5DF2\u7ECF\u5B9E\u73B0\u4E86\u5207\u6362\u7684UI\u66F4\u65B0\u903B\u8F91\u7684\u4E86\uFF0C\u53EA\u9700\u8981viewPager.bindIndicator(indicatorContainer)\u5373\u53EF\u3002\n  - \u79FB\u52A8\u7AEF\u7684ViewPager\u7684canIndicatorClick\u5C5E\u6027\u9ED8\u8BA4\u8BBE\u7F6E\u4E3Afalse\u7684\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8BF4\u660E\u9700\u8981\u6FC0\u6D3B\u6307\u793A\u5668\u7684\u70B9\u70B9\u51FB\u5207\u6362ViewPager\u3002\n  - \u6BCF\u4E00\u4E2A\u9875\u9762(\u5982loginPage)\u5EFA\u8BAE\u5728page\u6587\u4EF6\u5939\u4E0B\u9762\u521B\u5EFA\u4E00\u4E2A\u9875\u9762\u6587\u4EF6\u5939(\u5982login)\uFF0C\u7136\u540E\u9875\u9762\u7684ts\u6587\u4EF6(\u5982loginPage.ts)\u521B\u5EFA\u5728\u9875\u9762\u6587\u4EF6\u5939\u4E0B\u9762\uFF0C\u9875\u9762\u6587\u4EF6\u5939\u4E0B\u5982\u679C\u9700\u8981\u8FD8\u53EF\u521B\u5EFA\u4E00\u4E2A\u9875\u9762\u6570\u636Ets\u6587\u4EF6(\u5982loginPageData.ts)\uFF0C\u8FD9\u6837\u5982loginPage\u8D1F\u8D23\u4E1A\u52A1\u903B\u8F91\u548C\u4EA4\u4E92\u903B\u8F91\uFF0C\u5982loginPageData\u8D1F\u8D23\u6570\u636E\u58F0\u660E\u5B9A\u4E49\u3001\u521D\u59CB\u5316\u4E0E\u7BA1\u7406\u7B49\u3002\n\n## 8. **\u7406\u89E3\u540E\u7AEFAPI\u63A5\u53E3\u7684\u5B9A\u4E49\u4E0E\u4F7F\u7528**\n  - \u4F7F\u7528'read_file'\u5DE5\u5177\u8BFB\u53D6'src/backendApi/backendApiInfo.md'\u540E\u7AEFAPI\u4F7F\u7528\u8BF4\u660E\u6587\u4EF6\uFF0C\u5FC5\u987B\u7F13\u5B58\u8BB0\u4F4F\u6240\u6709\u53EF\u7528\u7684\u540E\u7AEFAPI\u63A5\u53E3\u5217\u8868\u3002\n  - \u540E\u7AEFAPI\u63A5\u53E3\u7684\u5B9A\u4E49\u4E0E\u4F7F\u7528\uFF0C\u5FC5\u987B\u4F7F\u7528src/backendApi\u6587\u4EF6\u5939\u91CC\u9762\u7684\u5404\u79CDAPI\u7C7B\u4E2D\u5B9A\u4E49\u7684\u65B9\u6CD5\uFF0C\u4E0D\u5141\u8BB8\u4F7F\u7528\u672A\u5728backendApi\u6587\u4EF6\u5939\u4E2D\u5B9A\u4E49\u7684\u540E\u7AEFAPI\uFF0C\u6BD4\u5982\uFF1AbackendApi/account/getUserInfo.ts\uFF0C\u8FD9\u4E2A\u5C31\u662F\u8D26\u53F7\u6A21\u5757\u4E2D\u7684\u83B7\u53D6\u7528\u6237\u4FE1\u606F\u7684API\u7C7B\uFF0C\u8FD4\u56DE\u7684res\u5FC5\u987B\u58F0\u660E\u5177\u4F53\u7C7B\u578B\uFF0C\u6BD4\u5982res: getUserInfoResponse\u3002\n  - request\u63A5\u53E3\u53EA\u9700\u5B9A\u4E49\u5373\u53EF\uFF0C\u4E0D\u9700\u8981\u5B9E\u73B0\uFF0C\u5E95\u5C42\u5DF2\u7ECF\u5B9E\u73B0\u3002\n  - API\u7C7B\u4EE3\u7801\u793A\u4F8B\uFF1A\n    ```typescript\n    import BaseApi from '../BaseApi'\n\n    // \u8D26\u53F7\u7CFB\u7EDF-\u8D26\u53F7\u5BC6\u7801\u767B\u5F55\u63A5\u53E3\u8BF7\u6C42\u6570\u636E\n    export interface postClientBizAuthLoginRequest {\n        username?: string\n        password?: string\n        key?: string\n        captcha?: string\n    }\n\n    // \u8D26\u53F7\u7CFB\u7EDF-\u8D26\u53F7\u5BC6\u7801\u767B\u5F55\u63A5\u53E3\u8FD4\u56DE\u6570\u636E\n    export interface postClientBizAuthLoginResponse {\n                    code: number\n                    msg: string\n                    data: {\n        access_token: string\n        }\n    }\n\n    // \u8D26\u53F7\u7CFB\u7EDF-\u8D26\u53F7\u5BC6\u7801\u767B\u5F55\u63A5\u53E3\u5931\u8D25\u8FD4\u56DE\u6570\u636E\n    export interface apiFailInfo {\n        msg: string\n        code: number\n    }\n\n    // \u8D26\u53F7\u7CFB\u7EDF-\u8D26\u53F7\u5BC6\u7801\u767B\u5F55\u63A5\u53E3\n    export default class postClientBizAuthLogin extends BaseApi  {\n\n        public static request_ArtuX1d8a6A(\n            request: postClientBizAuthLoginRequest,\n            success: (res: postClientBizAuthLoginResponse) => void,\n            fail: (error: apiFailInfo) => void\n        ): void { }\n\n    }\n    ```\n  - API\u7C7B\u7684\u4F7F\u7528\u65B9\u5F0F\uFF1A\u5148import API\u7C7B\uFF0C\u7136\u540E\u8C03\u7528API\u7C7B\u7684request\u65B9\u6CD5\uFF0C\u6BD4\u5982\uFF1A\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      // \u8BF7\u6C42\u6210\u529F\u540E\u7684\u5904\u7406\n    }, (error: apiFailInfo) => {\n      // \u8BF7\u6C42\u5931\u8D25\u540E\u7684\u5904\u7406\n    })\n    ...\n\n## 9. **\u7406\u89E3\u8C03\u7528\u540E\u7AEFapi\u63A5\u53E3\u8FD4\u56DE\u6570\u636E\u540E\u4E0EUI\u6570\u636E\u7ED1\u5B9A**\n  - \u5728\u8C03\u7528\u540E\u7AEFapi\u63A5\u53E3\u8FD4\u56DE\u6570\u636E\u540E\uFF0C\u9700\u8981\u6839\u636Evtype\u6765\u505A\u4E0D\u540C\u7684\u6570\u636E\u7ED1\u5B9A\uFF0C\u6BD4\u5982\uFF1A\n    - vtype=\"verticalListView\"\u3001vtype=\"horizontalListView\"\u3001vtype=\"viewPager\"\u7C7B\u578B\u7684\u8282\u70B9\u7EC4\u4EF6\uFF0C\u9700\u8981\u4F7F\u7528setDataList\u65B9\u6CD5\u6765\u7ED1\u5B9A\u6570\u636E\uFF0C\u6BD4\u5982\uFF1A\n      this.xxxVerticalListView.setDataList(response.data.list)\u3001this.xxxHorizontalListView.setDataList(response.data.list)\u3001this.xxxViewPager.setDataList(response.data.list)\n    - vtype=\"listItemCard\"\u3001vtype=\"oneViewPagerContent\"\u7C7B\u578B\u7684\u8282\u70B9\u7EC4\u4EF6\uFF0C\u9700\u8981\u6DF1\u5EA6\u904D\u5386\u5B83\u7684\u7B2C1\u4E2Aitem\u7684\u5B69\u5B50\uFF0C\u7136\u540E\u7ED3\u5408\u540E\u7AEFapi\u8FD4\u56DE\u7684xxxResponse\u7684\u6570\u636E\u7ED3\u6784\u7ED9\u7B2C1\u4E2Aitem\u8BBE\u7F6E\u6570\u636E\uFF0C\u6CE8\u610F\u53EA\u9700\u7ED9\u7B2C1\u4E2Aitem\u8282\u70B9\u8BBE\u7F6E\u6570\u636E\uFF0C\u800C\u4E0D\u662F\u6240\u6709item\u8282\u70B9\u90FD\u8BBE\u7F6E\u6570\u636E\uFF0C\u6BD4\u5982\uFF1A\n      ```typescript\n      // \u540E\u7AEFxxxApi\u8FD4\u56DE\u7684xxxResponse\u6570\u636E\u7ED3\u6784\n      export interface getRecommendBookListResponse {\n          code: number\n          msg: string\n          data: {\n              list: [\n                  {\n                      id: number // \u4E66\u7C4DID\n                      title: string // \u4E66\u7C4D\u6807\u9898\n                      author: string // \u4F5C\u8005\u540D\u79F0\n                      coverUrl: string // \u5C01\u9762\u56FE\u7247URL\n                      description: string // \u4E66\u7C4D\u7B80\u4ECB\n                      categoryName: string // \u5206\u7C7B\u540D\u79F0\n                  }\n              ] // \u4E66\u7C4D\u5217\u8868\n              total: number // \u603B\u6570\u91CF\n              page: number // \u5F53\u524D\u9875\u7801\n              size: number // \u6BCF\u9875\u6570\u91CF\n          }\n      }\n      ...\n      // \u8BBE\u7F6E\u4E66\u7C4D\u5217\u8868\u6570\u636E\n      this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)\n      // \u8BBE\u7F6E\u7B2C1\u4E2Aitem\u8282\u70B9\u6570\u636E\n      this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title\n      this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author\n      ...\n      // \u8BBE\u7F6E\u8F6E\u64AD\u6570\u636E\n      this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)\n      // \u8BBE\u7F6E\u7B2C1\u4E2Aitem\u8282\u70B9\u6570\u636E\n      this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title\n      ...\n      ```\n\n## 10. \u8F6E\u64ADViewPager\u7684\u6307\u793A\u5668\u70B9\u7684\u5207\u6362UI\u66F4\u65B0\u903B\u8F91\uFF0C\u4E0D\u5F97\u5728ts\u4EE3\u7801\u91CC\u9762\u8FDB\u884C\uFF0C\u56E0\u4E3AViewPager\u7684\u6307\u793A\u5668\u70B9\u7684\u5207\u6362UI\u66F4\u65B0\u903B\u8F91\u5DF2\u7ECF\u81EA\u52A8\u5B9E\u73B0\u4E86\uFF0C\u4F60\u4E0D\u9700\u8981\u518D\u624B\u52A8\u5B9E\u73B0\u3002\n\n## 11. \u7981\u7528\u4EE5\u4E0B6\u79CD\u4EE3\u7801\u5199\u6CD5\n- 1\u3001\u7981\u6B62\u5728\u51FD\u6570\u91CC\u9762\u5B9A\u4E49\u5185\u90E8\u51FD\u6570\uFF0C\u5FC5\u987B\u5B9A\u4E49\u51FD\u6570\u4E3A\u5168\u5C40\u51FD\u6570\n  - \u274C \u9519\u8BEF\u7684\u5199\u6CD5\uFF1A\n  ```typescript\n  private initView(): void {\n      const countCardData: number = () => {\n          // xxx\u4EE3\u7801\n      }\n      const count = countCardData()\n  }\n  ```\n  - \u2705 \u6B63\u786E\u7684\u5199\u6CD5\u662F\uFF1A\n  ```typescript\n  private initView(): void {\n      const count = this.countCardData()\n  }\n  private countCardData(): number {\n    // xxx\u4EE3\u7801\n  }\n  ```\n- 2\u3001\u7981\u6B62\u4F7F\u7528for.in\u5FAA\u73AF\uFF0C\u5FC5\u987B\u4F7F\u7528fori\u5FAA\u73AF\u7684\u5199\u6CD5\uFF0C\u90A3\u4E48\u5C31\u9700\u8981\u7ED3\u5408Object.keys(xxx)\u6765\u5148\u83B7\u53D6\u5230\u5BF9\u8C61\u7684keys\uFF0C\u518Dfori\u904D\u5386\u5BF9\u8C61\u5C5E\u6027\n  - \u274C \u9519\u8BEF\u7684\u5199\u6CD5\uFF1A\n  ```typescript\n  for (const key in hotReviewObj) {\n      updatedReview[key] = hotReviewObj[key];\n  }\n  ```\n  - \u2705 \u6B63\u786E\u7684\u5199\u6CD5\u662F\uFF1A\n  ```typescript\n  const keys = Object.keys(hotReviewsData);\n  for (let i = 0; i < keys.length; i++) {\n      updatedReview[key] = hotReviewsData[keys[i]];\n  }\n  ```\n- 3\u3001\u4EFB\u4F55\u65B9\u6CD5\u51FD\u6570\u5B9A\u4E49\uFF0C\u7EDD\u5BF9\u7981\u6B62\u4F7F\u7528async\u548CPromise\uFF0C\u4E0D\u5141\u8BB8\u4F7F\u7528Promise.race\u3001Promise.all\u7B49Promise\u76F8\u5173\u65B9\u6CD5\uFF0C\u6240\u6709\u5F02\u6B65\u64CD\u4F5C\u5FC5\u987B\u4F7F\u7528\u7BAD\u5934\u51FD\u6570\u3002\n- 4\u3001\u7981\u6B62\u4F7F\u7528\u6B63\u5219\uFF0C\u8BF7\u4F7F\u7528\u5B57\u7B26\u4E32\u64CD\u4F5C\u6765\u66FF\u6362\u5B9E\u73B0\n- 5\u3001\u7981\u6B62\u4F7F\u7528lib.dom.d.ts\u6587\u4EF6\u91CC\u9762\u7684\u65B9\u6CD5\uFF0C\u56E0\u4E3Alib.dom.d.ts\u6587\u4EF6\u91CC\u9762\u7684\u65B9\u6CD5\u90FD\u662F\u6D4F\u89C8\u5668\u73AF\u5883\u7684\u65B9\u6CD5\uFF0C\u4E0D\u5141\u8BB8\u5728Node.js\u73AF\u5883\u4E0B\u4F7F\u7528\u3002\n- 6\u3001\u7981\u6B62\u4FEE\u6539\u3001\u65B0\u589E\u3001\u5220\u9664src/lib\u6587\u4EF6\u5939\u53CA\u5176\u6240\u6709\u5B50\u6587\u4EF6\u5939\u4E2D\u7684\u6587\u4EF6\u3002\n\n";
+//# sourceMappingURL=appCodeRule.d.ts.map

package/build/appCodeRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appCodeRule.d.ts","sourceRoot":"","sources":["../src/appCodeRule.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kCAAkC,u90BA8R9C,CAAC"}