deveco-harness 0.1.0

package/skills/arkts-error-fixes/reference/interface_method_signature_errors.md

@@ -0,0 +1,143 @@
+# Interface Method Signature Errors
+
+## Error: Interface method signature mismatch
+
+### Error Message
+```
+Object literal must correspond to some explicitly declared class or interface
+```
+
+### Cause
+When implementing an interface with an object literal, method signatures in the object must match the interface exactly. Using method syntax (`method() {}`) instead of property syntax (`method: () => {}`) causes type errors.
+
+### Solution
+Use property syntax for methods in object literals that implement interfaces. Change `method() {}` to `method: () => {}`.
+
+### Key Points
+- Use property syntax for methods in object literals
+- Change `method(): ReturnType {}` to `method: () => ReturnType {}`
+- Ensure parameter types match to interface
+- Ensure return types match to interface
+
+### Basic Pattern
+```typescript
+// ❌ Wrong: Method syntax in object literal
+interface MyInterface {
+  updateWindowInfo(): void;
+  destroy(): void;
+}
+
+const myObject: MyInterface = {
+  updateWindowInfo(): void {
+    console.log('Updated');
+  },
+  destroy(): void {
+    console.log('Destroyed');
+  }
+};
+
+// ✅ Correct: Property syntax in object literal
+interface MyInterface {
+  updateWindowInfo: () => void;
+  destroy: () => void;
+}
+
+const myObject: MyInterface = {
+  updateWindowInfo: () => {
+    console.log('Updated');
+  },
+  destroy: () => {
+    console.log('Destroyed');
+  }
+};
+```
+
+### Common Patterns
+```typescript
+// No parameters
+interface SimpleInterface {
+  doSomething: () => void;
+}
+
+const obj: SimpleInterface = {
+  doSomething: () => {
+    console.log('Doing something');
+  }
+};
+
+// With parameters
+interface ParameterInterface {
+  calculate: (a: number, b: number) => number;
+}
+
+const obj: ParameterInterface = {
+  calculate: (a: number, b: number): number => {
+    return a + b;
+  }
+};
+
+// With optional parameters
+interface OptionalInterface {
+  process: (data: string, options?: Options) => void;
+}
+
+const obj: OptionalInterface = {
+  process: (data: string, options?: Options): void => {
+    console.log(data, options);
+  }
+};
+```
+
+### Detailed Examples
+For more detailed code examples, see:
+- [Interface Definition](../assets/InterfaceMethodSignatureError.ets#L1-L6)
+- [Object Literal Implementation](../assets/InterfaceMethodSignatureError.ets#L8-L24)
+- [Usage Pattern](../assets/InterfaceMethodSignatureError.ets#L26-L42)
+
+### Best Practices
+1. **Use property syntax**: Always use `method: () => {}` syntax for object literals
+2. **Match signatures**: Ensure method signatures match to interface exactly
+3. **Add type annotations**: Add explicit parameter and return types
+4. **Keep interfaces simple**: Avoid overly complex method signatures
+5. **Document interfaces**: Add comments explaining interface purpose
+
+### Common Mistakes
+```typescript
+// ❌ Wrong: Method syntax in object literal
+interface MyInterface {
+  updateWindowInfo(): void;
+}
+
+const obj: MyInterface = {
+  updateWindowInfo(): void {
+    console.log('Updated');
+  }
+};
+
+// ❌ Wrong: Method syntax in object literal
+interface MyInterface {
+  updateWindowInfo: () => void;
+}
+
+const obj: MyInterface = {
+  updateWindowInfo(): void {
+    console.log('Updated');
+  }
+};
+
+// ✅ Correct: Property syntax in object literal
+interface MyInterface {
+  updateWindowInfo: () => void;
+}
+
+const obj: MyInterface = {
+  updateWindowInfo: () => {
+    console.log('Updated');
+  }
+};
+```
+
+### Related Files
+- [Code Example](../assets/InterfaceMethodSignatureError.ets)
+- [Object Literal Interface Errors](./object_literal_interface_errors.md)
+- [ArkTS Language Guide](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-get-started)

package/skills/arkts-error-fixes/reference/notification_errors.md

@@ -0,0 +1,110 @@
+# Notification API Type Errors
+
+## Error: `notificationManager.ContentType` type incompatibility
+
+### Error Message
+```
+Type 'notificationManager.ContentType' is not assignable to type 'notification.ContentType'
+```
+
+### Cause
+Type mismatch between `notificationManager.ContentType` and `notification.ContentType`. The `notificationManager.ContentType` enum has additional properties that are not present in `notification.ContentType`, causing type incompatibility.
+
+### Solution
+Cast the ContentType value to `number` type to resolve the type incompatibility.
+
+### Key Points
+- Import from `@kit.NotificationKit`: `import { notificationManager } from '@kit.NotificationKit'`
+- Cast to `number`: `as number` when assigning to `contentType`
+- Use proper error handling with `BusinessError`
+- Use `hilog` for logging instead of `console`
+
+### Notification Request Structure
+```typescript
+interface NotificationRequest {
+  id: number;
+  content: NotificationContent;
+  notificationSlotType?: SlotType;
+  isOngoing?: boolean;
+  isUnremovable?: boolean;
+  deliveryTime?: number;
+  tapDismissed?: boolean;
+  autoDeletedTime?: number;
+  classification?: Classification;
+  groupName?: string;
+  slotType?: SlotType;
+  ...
+}
+```
+
+### Content Types
+```typescript
+notificationManager.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT
+notificationManager.ContentType.NOTIFICATION_CONTENT_LONG_TEXT
+notificationManager.ContentType.NOTIFICATION_CONTENT_PICTURE
+notificationManager.ContentType.NOTIFICATION_CONTENT_CONVERSATION
+notificationManager.ContentType.NOTIFICATION_CONTENT_MULTILINE
+notificationManager.ContentType.NOTIFICATION_CONTENT_MEDIA
+notificationManager.ContentType.NOTIFICATION_CONTENT_LOCAL_LIVE_VIEW
+notificationManager.ContentType.NOTIFICATION_CONTENT_LIVE_VIEW
+```
+
+### Basic Text Content
+```typescript
+interface NotificationBasicContent {
+  title: string;
+  text: string;
+  additionalText?: string;
+  largeIcon?: string;
+  briefText?: string;
+  expandedTitle?: string;
+}
+```
+
+### Publishing Pattern
+```typescript
+let notificationRequest: notificationManager.NotificationRequest = {
+  id: 1,
+  content: {
+    contentType: notificationManager.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT as number,
+    normal: {
+      title: 'Test Notification',
+      text: 'This is a test notification',
+      additionalText: 'Additional text'
+    }
+  }
+};
+
+notificationManager.publish(notificationRequest)
+  .then(() => {
+    hilog.info(0x0000, 'testTag', 'Publish notification success');
+  })
+  .catch((err: BusinessError) => {
+    hilog.error(0x0000, 'testTag', 'Publish notification failed: %{public}s', JSON.stringify(err));
+  });
+```
+
+### Error Handling
+```typescript
+// Common error codes
+if (err.code === 1600001) {
+  // Notification not enabled
+} else if (err.code === 1600002) {
+  // Too many notifications
+} else if (err.code === 1600003) {
+  // Invalid notification
+} else if (err.code === 1600004) {
+  // Notification slot not found
+}
+```
+
+### Best Practices
+1. **Cast to number**: Always cast ContentType to `number` to avoid type errors
+2. **Use hilog**: Use `hilog` instead of `console` for better logging
+3. **Handle errors**: Always catch and handle BusinessError
+4. **Use unique IDs**: Ensure notification IDs are unique
+5. **Test permissions**: Verify notification permissions are granted
+
+### Related Files
+- [Code Example](../assets/NotificationError.ets)
+- [Notification Kit Documentation](https://developer.huawei.com/consumer/cn/doc/harmonyos-references-V5/ts-api-notificationmanager-V5)

package/skills/arkts-error-fixes/reference/object_literal_interface_errors.md

@@ -0,0 +1,156 @@
+# Object Literal Interface Errors
+
+## Error: `Object literal must correspond to some explicitly declared class or interface`
+
+### Error Message
+```
+Object literal must correspond to some explicitly declared class or interface
+```
+
+### Cause
+ArkTS has strict type checking for object literals. When you create an object literal, it must match an explicitly declared interface or class. This prevents type errors and ensures type safety.
+
+### Solution
+Define an interface or class that describes the shape of the object literal, then use that type for the object.
+
+### Key Points
+- Define interfaces for object shapes before using them
+- Use the interface type for arrays of objects
+- Ensure object literals match the interface exactly
+- Use optional properties (`?`) for fields that may not be present
+
+### Basic Pattern
+```typescript
+interface Article {
+  title: string;
+  desc: string;
+  image: Resource;
+}
+
+@Entry
+@Component
+struct MyComponent {
+  private articles: Article[] = [
+    { title: '文章1', desc: '这是文章1的描述', image: $r('app.media.article1') },
+    { title: '文章2', desc: '这是文章2的描述', image: $r('app.media.article2') }
+  ];
+
+  build() {
+    ForEach(this.articles, (article: Article) => {
+      Text(article.title)
+    })
+  }
+}
+```
+
+### Interface Definition
+```typescript
+// Basic interface
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// Interface with optional properties
+interface Config {
+  width: number;
+  height: number;
+  color?: string;
+  opacity?: number;
+}
+
+// Interface with nested objects
+interface Article {
+  title: string;
+  desc: string;
+  image: Resource;
+  metadata?: {
+    author: string;
+    date: string;
+  };
+}
+```
+
+### Common Patterns
+```typescript
+// Configuration object
+interface Config {
+  width: number;
+  height: number;
+  color: string;
+}
+
+const config: Config = { width: 100, height: 100, color: 'red' };
+
+// User data
+interface User {
+  id: number;
+  name: string;
+  email?: string;
+}
+
+const user: User = { id: 1, name: 'John' };
+
+// API response
+interface ApiResponse {
+  success: boolean;
+  data: any;
+  message?: string;
+}
+
+const response: ApiResponse = { success: true, data: {} };
+
+// Breakpoint configuration
+interface Breakpoint {
+  name: string;
+  range: [number, number];
+}
+
+const breakpoints: Breakpoint[] = [
+  { name: 'sm', range: [320, 599] },
+  { name: 'md', range: [600, 839] }
+];
+```
+
+### Detailed Examples
+For more detailed code examples, see:
+- [Interface Definition](../assets/ObjectLiteralInterfaceError.ets#L1-L6)
+- [Array of Objects](../assets/ObjectLiteralInterfaceError.ets#L8-L14)
+- [ForEach Usage](../assets/ObjectLiteralInterfaceError.ets#L16-L48)
+
+### Best Practices
+1. **Define interfaces first**: Always define interfaces before using object literals
+2. **Use descriptive names**: Interface names should clearly describe the object shape
+3. **Make properties optional**: Use `?` for properties that may not be present
+4. **Reuse interfaces**: Define interfaces once and reuse them throughout your code
+5. **Document interfaces**: Add comments explaining the purpose of each interface
+
+### Common Mistakes
+```typescript
+// ❌ Wrong: Object literal without interface
+const articles = [
+  { title: '文章1', desc: '描述', image: $r('app.media.icon') }
+];
+
+// ❌ Wrong: Array type with object literal
+const articles: Array<{ title: string, desc: string, image: Resource }> = [
+  { title: '文章1', desc: '描述', image: $r('app.media.icon') }
+];
+
+// ✅ Correct: Define interface first
+interface Article {
+  title: string;
+  desc: string;
+  image: Resource;
+}
+
+const articles: Article[] = [
+  { title: '文章1', desc: '描述', image: $r('app.media.icon') }
+];
+```
+
+### Related Files
+- [Code Example](../assets/ObjectLiteralInterfaceError.ets)
+- [Object Spread Type Errors](./object_spread_errors.md)
+- [ArkTS Language Guide](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-get-started)

package/skills/arkts-error-fixes/reference/object_literal_type_errors.md

@@ -0,0 +1,110 @@
+# Object Literal Type Declaration Error
+
+## 错误描述
+
+在 ArkTS 中，不能使用对象字面量作为类型声明。必须使用 `interface` 或 `class` 来定义类型。
+
+## 错误示例
+
+```typescript
+function getWindowSize(): { width: number; height: number } {
+  return { width: 100, height: 200 };
+}
+```
+
+**错误信息：**
+```
+Object literals cannot be used as type declarations (arkts-no-obj-literals-as-types)
+```
+
+## 解决方案
+
+### 方案1：使用 interface（推荐）
+
+```typescript
+interface WindowSize {
+  width: number;
+  height: number;
+}
+
+function getWindowSize(): WindowSize {
+  return { width: 100, height: 200 };
+}
+```
+
+### 方案2：使用 type 别名
+
+```typescript
+type WindowSize = {
+  width: number;
+  height: number;
+};
+
+function getWindowSize(): WindowSize {
+  return { width: 100, height: 200 };
+}
+```
+
+### 方案3：使用 class
+
+```typescript
+class WindowSize {
+  width: number = 0;
+  height: number = 0;
+}
+
+function getWindowSize(): WindowSize {
+  const size = new WindowSize();
+  size.width = 100;
+  size.height = 200;
+  return size;
+}
+```
+
+## 详细说明
+
+ArkTS 禁止使用对象字面量作为类型声明，这是为了：
+
+1. **提高代码可读性**：使用命名的类型更清晰
+2. **支持类型复用**：interface 和 type 可以在多个地方使用
+3. **增强类型检查**：明确的类型定义可以提供更好的类型推断
+
+## 简单示例
+
+```typescript
+interface WindowSize {
+  width: number;
+  height: number;
+}
+
+@Entry
+@Component
+struct WindowSizeExample {
+  @State windowSize: WindowSize = { width: 0, height: 0 };
+
+  aboutToAppear() {
+    this.windowSize = this.getWindowSize();
+  }
+
+  private getWindowSize(): WindowSize {
+    const windowStage = this.getUIContext().getHostContext() as common.UIAbilityContext;
+    const windowClass = windowStage.getMainWindowSync();
+    const windowProperties = windowClass.getWindowProperties();
+    return {
+      width: windowProperties.windowRect.width,
+      height: windowProperties.windowRect.height
+    };
+  }
+
+  build() {
+    Column() {
+      Text(`宽度: ${this.windowSize.width}`)
+      Text(`高度: ${this.windowSize.height}`)
+    }
+  }
+}
+```
+
+## 详细代码示例
+
+> [ObjectLiteralTypeError.ets](../assets/ObjectLiteralTypeError.ets) - 完整的对象字面量类型声明错误示例和修复方案

package/skills/arkts-error-fixes/reference/object_spread_errors.md

@@ -0,0 +1,105 @@
+# Object Spread Type Errors
+
+## Error: Object spread type inference issue
+
+### Error Message
+```
+Type inference errors when using object spread
+```
+
+### Cause
+ArkTS has strict type inference rules for object spread operations. Without explicit type annotations, the compiler cannot properly infer the resulting type.
+
+### Solution
+Explicitly type objects or use proper interface definitions before using spread operations.
+
+### Key Points
+- Define interfaces for object shapes
+- Use explicit type annotations for spread results
+- Ensure spread and target types are compatible
+- Use optional properties for partial updates
+
+### Interface Definition
+```typescript
+interface Config {
+  width: number;
+  height: number;
+  color?: string;
+  opacity?: number;
+}
+```
+
+### Spread Pattern
+```typescript
+const baseConfig: Config = { width: 100, height: 100 };
+const newConfig: Config = { ...baseConfig, color: 'red' };
+```
+
+### Partial Updates
+```typescript
+interface User {
+  id: number;
+  name: string;
+  email?: string;
+  phone?: string;
+}
+
+const baseUser: User = { id: 1, name: 'John' };
+const updatedUser: User = { 
+  ...baseUser, 
+  email: 'john@example.com' 
+};
+```
+
+### Nested Objects
+```typescript
+interface NestedConfig {
+  layout: {
+    width: number;
+    height: number;
+  };
+  style: {
+    color: string;
+    opacity: number;
+  };
+}
+
+const base: NestedConfig = {
+  layout: { width: 100, height: 100 },
+  style: { color: 'red', opacity: 1.0 }
+};
+
+const updated: NestedConfig = {
+  ...base,
+  layout: { ...base.layout, width: 200 }
+};
+```
+
+### Common Patterns
+```typescript
+// Configuration update
+const config: Config = { ...defaultConfig, ...userConfig };
+
+// State update
+const newState: State = { ...currentState, ...updates };
+
+// Merge defaults
+const merged: Options = { ...defaultOptions, ...userOptions };
+
+// Conditional spread
+const result: Result = {
+  ...base,
+  ...(condition ? { extra: 'value' } : {})
+};
+```
+
+### Best Practices
+1. **Define interfaces**: Always define interfaces for object shapes
+2. **Use explicit types**: Annotate spread results with interface types
+3. **Optional properties**: Use optional properties for partial updates
+4. **Type compatibility**: Ensure spread and target types are compatible
+5. **Avoid deep spread**: Be careful with nested object spreads
+
+### Related Files
+- [Code Example](../assets/ObjectSpreadError.ets)
+- [ArkTS Language Guide](https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-get-started)