bytefun-ai-mcp/build/jumpPageCode.js

ByteFun AI MCP服务 - 打通产品设计、UI设计、代码开发的服务平台，支持设计稿转代码和跨平台原生代码开发

export const codePromptTemplate = `# 你是typescript代码专家，根据\`编写规则\`帮我完成\`src/{{功能模块}}/{{页面名字}}/{{页面名字}}.ts\`页面跳转代码的开发

## 代码规范
- **结尾禁止分号**：一句代码的结尾禁止写分号，不需要写分号的

## **核心原则**
- 只实现页面跳转和关闭页面的代码，其他任何代码不允许编写
- 绝对禁止注释页面跳转代码，即使跳转的目标页面的UI还没有开发完毕，也要先写上页面跳转代码，否则用户会认为你没有实现页面跳转代码
- 必须要完成所有页面的页面跳转代码开发才能结束任务，才能停止该AI会话

## **🚨 严格禁止事项 - 防止AI大模型错误实现**

### **绝对禁止实现的功能代码**
- **❌ 禁止实现任何UI显示与交互逻辑**：不得编写toast、dialog、text、input等UI显示相关代码
- **❌ 禁止实现非页面跳转的逻辑**：不得编写任何与页面跳转无关的逻辑代码
- **❌ 禁止实现网络请求逻辑**：不得编写API调用、数据获取等网络相关方法，请使用延时执行来模拟请求过程
- **❌ 禁止实现状态管理逻辑**：不得编写复杂的状态切换、数据管理等状态方法
- **❌ 禁止实现业务逻辑方法**：不得编写任何与页面跳转无关的业务处理方法

### **只允许实现的代码类型**
- **✅ 组件声明**：声明页面中可点击的UI组件（按钮、链接等）
- **✅ 点击事件绑定**：为可点击组件绑定setOnClickListener事件
- **✅ 页面跳转调用**：在setOnClickListener事件中调用AllFunction.startPage(page: Page)进行页面跳转
- **✅ 关闭页面调用**：在setOnClickListener事件中调用AllFunction.closePage()进行页面关闭
- **✅ 简单延时跳转**：使用AllFunction.setTimeout实现延时跳转（如闪屏页）

### **错误实现示例（绝对禁止）**
\`\`\`typescript
// ❌ 错误：实现了Toast显示逻辑
private showToast(type: string): void {
    this.loginSuccessToast.visibility = ViewVisibility.VISIBLE
    // ... 更多Toast逻辑
}

// ❌ 错误：实现了登录验证逻辑
private handleLogin(): void {
    // 模拟登录过程
    AllFunction.setTimeout(() => {
        this.showToast('success')
        // ... 更多登录逻辑
    }, 2000)
}

// ❌ 错误：实现了复杂的业务逻辑
private handleGetVerificationCode(): void {
    // 模拟获取验证码
    AllFunction.setTimeout(() => {
        this.showToast('codeSent')
    }, 1000)
}
\`\`\`

### **正确实现示例（严格遵循）**
\`\`\`typescript
// ✅ 正确：只实现页面跳转
export default class xxxPage extends Page {
    // 声明必要的可点击组件
    private registerLink: ButtonView = this.findViewById('registerLink') as ButtonView
    private loginButton: ButtonView = this.findViewById('loginButton') as ButtonView
    private backButton: ButtonView = this.findViewById('backButton') as ButtonView

    private initView(): void {
        // 只绑定页面跳转事件
        this.registerLink.setOnClickListener(() => {
            AllFunction.startPage(new RegisterPage())
        })

        this.loginButton.setOnClickListener(() => {
            AllFunction.startPage(new HomePage())
        })

        this.backButton.setOnClickListener(() => {
            AllFunction.closePage()
        })
    }
}
\`\`\`

### **AI大模型常见错误思维模式**
1. **过度解读UI结构**：看到Toast组件就认为需要实现Toast功能 ❌
2. **基于开发经验**：认为页面需要完整的业务逻辑与交互逻辑 ❌
3. **功能完整性误解**：认为需要实现页面的所有功能 ❌
4. **忽略明确指令**：没有严格遵循"只实现页面跳转"的要求 ❌

### **正确的AI思维模式**
1. **严格按指令执行**：只实现页面跳转，其他一律不写 ✅
2. **明确任务边界**：页面跳转 ≠ 页面功能 ✅
3. **简洁实现原则**：最少代码完成跳转需求 ✅
4. **忽略UI复杂性**：不管UI多复杂，只关注跳转逻辑 ✅

## 首先，读取\`doc/UI设计进度.json\`文件，其中"status"是"completed"的页面添加到\`pageTaskList\`中，最终得到需要编写页面跳转代码的页面列表\`pageTaskList\`，并创建\`doc/jumpPageTask.json\`文件，将\`pageTaskList\`带任务完成状态的json写入到\`doc/jumpPageTask.json\`文件中，其中version从0开始，每次设计或修复完成一个页面，version就加1，jumpPageTask.json文件的json的格式为：
\`\`\`json
{
  "pageTaskList": [
    {
      "pageNameEN": "xxxPage",
      "pageNameCN": "xxx页面",
      "versoin": 1,
      "status": "completed"
    },
    {
      "pageNameEN": "xxxPage",
      "pageNameCN": "xxx页面",
      "versoin": 0,
      "status": "pending"
    }
  ]
}
\`\`\`

## 然后调用todo_write工具根据\`pageTaskList\`创建任务列表，一个页面一个任务

## 然后，每一个页面的开发都必须按照\`编写规则\`，并读取页面UI描述文件\`src/{模块名字}/xxxPage/xxxPage.md\`，理解页面的结构和组件元素，完成\`src/{模块名字}/xxxPage/xxxPage.ts\`的页面跳转代码的开发之后，还需要更新\`doc/jumpPageTask.json\`文件中的任务完成状态status字段和version字段，version字段每次都加1

## 最后，读取\`doc/jumpPageTask.json\`文件，判断是否所有页面的页面跳转代码都开发完成，如果完成就结束任务，否则继续开发下一个页面的页面跳转代码任务

### 编写规则

#### **理解View组件的声明规则**
- AllFunction的import语句必须在类文件开始时先声明，并且import代码必须是这样写，特别注意严格按照下面给出的路径写法：
  \`\`\`typescript
  import AllFunction from "../../lib/AllFunction"
  \`\`\`
- 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的
- View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView
- 使用工具遍历'src/lib/uilib/'文件夹下面的文件列表名字，理解总共有多少种UI组件
- 一个页面的所有View的信息数据都在\`src/{模块名字}/xxxPage/xxxPage.md\`文件中，该文件中会详细描述每个View的类型、id、xywh等属性
- 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
    ....
  }
  \`\`\`

#### **理解点击事件的绑定规则**
- 点击事件的绑定必须使用setOnClickListener方法实现，setOnClickListener方法传入一个函数，函数中实现点击事件的逻辑，比如：
  \`\`\`typescript
  public class HomePage extends Page {
    private nameTextView: TextView = this.findViewById('nameTextView') as TextView
    ....
    private initView() {
      this.nameTextView.setOnClickListener(() => {
        AllFunction.startPage(new ProductPage())
      })
    }
  }
  \`\`\`

#### **理解页面跳转规则**
- 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage())。
- 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码。
- 在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'。

#### **理解延时执行的代码规则**
- 延时执行只能使用AllFunction.setTimeout实现，不能使用setTimeout函数，比如：
  \`\`\`typescript
  AllFunction.setTimeout(() => {
    console.log('延时执行')
  }, 1000)
  \`\`\`
  - ❌ 错误的写法（使用setTimeout函数）：
  \`\`\`typescript
  setTimeout(() => {
    console.log('延时执行')
  }, 1000)
  \`\`\`
- 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。

#### **理解网络请求的模拟规则**
- 关于网络请求的模拟请使用延时执行来模拟请求过程，因为这只是页面跳转实现不需要网络数据，比如：
  \`\`\`typescript
  AllFunction.simulateNetRequest(() => {
    console.log('网络请求完成')
  }, 2000)
  \`\`\`
- 不得使用任何其他工具实现网络请求的模拟，比如：simulateNetRequest等

  `;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jumpPageCode.js","sourceRoot":"","sources":["../src/jumpPageCode.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2M/B,CAAC","sourcesContent":["export const codePromptTemplate = `# 你是typescript代码专家，根据\\`编写规则\\`帮我完成\\`src/{{功能模块}}/{{页面名字}}/{{页面名字}}.ts\\`页面跳转代码的开发\n\n## 代码规范\n- **结尾禁止分号**：一句代码的结尾禁止写分号，不需要写分号的\n\n## **核心原则**\n- 只实现页面跳转和关闭页面的代码，其他任何代码不允许编写\n- 绝对禁止注释页面跳转代码，即使跳转的目标页面的UI还没有开发完毕，也要先写上页面跳转代码，否则用户会认为你没有实现页面跳转代码\n- 必须要完成所有页面的页面跳转代码开发才能结束任务，才能停止该AI会话\n\n## **🚨 严格禁止事项 - 防止AI大模型错误实现**\n\n### **绝对禁止实现的功能代码**\n- **❌ 禁止实现任何UI显示与交互逻辑**：不得编写toast、dialog、text、input等UI显示相关代码\n- **❌ 禁止实现非页面跳转的逻辑**：不得编写任何与页面跳转无关的逻辑代码\n- **❌ 禁止实现网络请求逻辑**：不得编写API调用、数据获取等网络相关方法，请使用延时执行来模拟请求过程\n- **❌ 禁止实现状态管理逻辑**：不得编写复杂的状态切换、数据管理等状态方法\n- **❌ 禁止实现业务逻辑方法**：不得编写任何与页面跳转无关的业务处理方法\n\n### **只允许实现的代码类型**\n- **✅ 组件声明**：声明页面中可点击的UI组件（按钮、链接等）\n- **✅ 点击事件绑定**：为可点击组件绑定setOnClickListener事件\n- **✅ 页面跳转调用**：在setOnClickListener事件中调用AllFunction.startPage(page: Page)进行页面跳转\n- **✅ 关闭页面调用**：在setOnClickListener事件中调用AllFunction.closePage()进行页面关闭\n- **✅ 简单延时跳转**：使用AllFunction.setTimeout实现延时跳转（如闪屏页）\n\n### **错误实现示例（绝对禁止）**\n\\`\\`\\`typescript\n// ❌ 错误：实现了Toast显示逻辑\nprivate showToast(type: string): void {\n    this.loginSuccessToast.visibility = ViewVisibility.VISIBLE\n    // ... 更多Toast逻辑\n}\n\n// ❌ 错误：实现了登录验证逻辑\nprivate handleLogin(): void {\n    // 模拟登录过程\n    AllFunction.setTimeout(() => {\n        this.showToast('success')\n        // ... 更多登录逻辑\n    }, 2000)\n}\n\n// ❌ 错误：实现了复杂的业务逻辑\nprivate handleGetVerificationCode(): void {\n    // 模拟获取验证码\n    AllFunction.setTimeout(() => {\n        this.showToast('codeSent')\n    }, 1000)\n}\n\\`\\`\\`\n\n### **正确实现示例（严格遵循）**\n\\`\\`\\`typescript\n// ✅ 正确：只实现页面跳转\nexport default class xxxPage extends Page {\n    // 声明必要的可点击组件\n    private registerLink: ButtonView = this.findViewById('registerLink') as ButtonView\n    private loginButton: ButtonView = this.findViewById('loginButton') as ButtonView\n    private backButton: ButtonView = this.findViewById('backButton') as ButtonView\n\n    private initView(): void {\n        // 只绑定页面跳转事件\n        this.registerLink.setOnClickListener(() => {\n            AllFunction.startPage(new RegisterPage())\n        })\n\n        this.loginButton.setOnClickListener(() => {\n            AllFunction.startPage(new HomePage())\n        })\n\n        this.backButton.setOnClickListener(() => {\n            AllFunction.closePage()\n        })\n    }\n}\n\\`\\`\\`\n\n### **AI大模型常见错误思维模式**\n1. **过度解读UI结构**：看到Toast组件就认为需要实现Toast功能 ❌\n2. **基于开发经验**：认为页面需要完整的业务逻辑与交互逻辑 ❌\n3. **功能完整性误解**：认为需要实现页面的所有功能 ❌\n4. **忽略明确指令**：没有严格遵循\"只实现页面跳转\"的要求 ❌\n\n### **正确的AI思维模式**\n1. **严格按指令执行**：只实现页面跳转，其他一律不写 ✅\n2. **明确任务边界**：页面跳转 ≠ 页面功能 ✅\n3. **简洁实现原则**：最少代码完成跳转需求 ✅\n4. **忽略UI复杂性**：不管UI多复杂，只关注跳转逻辑 ✅\n\n## 首先，读取\\`doc/UI设计进度.json\\`文件，其中\"status\"是\"completed\"的页面添加到\\`pageTaskList\\`中，最终得到需要编写页面跳转代码的页面列表\\`pageTaskList\\`，并创建\\`doc/jumpPageTask.json\\`文件，将\\`pageTaskList\\`带任务完成状态的json写入到\\`doc/jumpPageTask.json\\`文件中，其中version从0开始，每次设计或修复完成一个页面，version就加1，jumpPageTask.json文件的json的格式为：\n\\`\\`\\`json\n{\n  \"pageTaskList\": [\n    {\n      \"pageNameEN\": \"xxxPage\",\n      \"pageNameCN\": \"xxx页面\",\n      \"versoin\": 1,\n      \"status\": \"completed\"\n    },\n    {\n      \"pageNameEN\": \"xxxPage\",\n      \"pageNameCN\": \"xxx页面\",\n      \"versoin\": 0,\n      \"status\": \"pending\"\n    }\n  ]\n}\n\\`\\`\\`\n\n## 然后调用todo_write工具根据\\`pageTaskList\\`创建任务列表，一个页面一个任务\n\n## 然后，每一个页面的开发都必须按照\\`编写规则\\`，并读取页面UI描述文件\\`src/{模块名字}/xxxPage/xxxPage.md\\`，理解页面的结构和组件元素，完成\\`src/{模块名字}/xxxPage/xxxPage.ts\\`的页面跳转代码的开发之后，还需要更新\\`doc/jumpPageTask.json\\`文件中的任务完成状态status字段和version字段，version字段每次都加1\n\n## 最后，读取\\`doc/jumpPageTask.json\\`文件，判断是否所有页面的页面跳转代码都开发完成，如果完成就结束任务，否则继续开发下一个页面的页面跳转代码任务\n\n### 编写规则\n\n#### **理解View组件的声明规则**\n- AllFunction的import语句必须在类文件开始时先声明，并且import代码必须是这样写，特别注意严格按照下面给出的路径写法：\n  \\`\\`\\`typescript\n  import AllFunction from \"../../lib/AllFunction\"\n  \\`\\`\\`\n- 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的\n- View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView\n- 使用工具遍历'src/lib/uilib/'文件夹下面的文件列表名字，理解总共有多少种UI组件\n- 一个页面的所有View的信息数据都在\\`src/{模块名字}/xxxPage/xxxPage.md\\`文件中，该文件中会详细描述每个View的类型、id、xywh等属性\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\n#### **理解点击事件的绑定规则**\n- 点击事件的绑定必须使用setOnClickListener方法实现，setOnClickListener方法传入一个函数，函数中实现点击事件的逻辑，比如：\n  \\`\\`\\`typescript\n  public class HomePage extends Page {\n    private nameTextView: TextView = this.findViewById('nameTextView') as TextView\n    ....\n    private initView() {\n      this.nameTextView.setOnClickListener(() => {\n        AllFunction.startPage(new ProductPage())\n      })\n    }\n  }\n  \\`\\`\\`\n\n#### **理解页面跳转规则**\n- 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage())。\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\n#### **理解延时执行的代码规则**\n- 延时执行只能使用AllFunction.setTimeout实现，不能使用setTimeout函数，比如：\n  \\`\\`\\`typescript\n  AllFunction.setTimeout(() => {\n    console.log('延时执行')\n  }, 1000)\n  \\`\\`\\`\n  - ❌ 错误的写法（使用setTimeout函数）：\n  \\`\\`\\`typescript\n  setTimeout(() => {\n    console.log('延时执行')\n  }, 1000)\n  \\`\\`\\`\n- 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。\n\n#### **理解网络请求的模拟规则**\n- 关于网络请求的模拟请使用延时执行来模拟请求过程，因为这只是页面跳转实现不需要网络数据，比如：\n  \\`\\`\\`typescript\n  AllFunction.simulateNetRequest(() => {\n    console.log('网络请求完成')\n  }, 2000)\n  \\`\\`\\`\n- 不得使用任何其他工具实现网络请求的模拟，比如：simulateNetRequest等\n\n  `;"]}