arkts-helper

ArkTS is the official high-level language for HarmonyOS application development, extending and constraining the TypeScript (TS) ecosystem:

• Mandatory static typing: All variables must have declared types; any/unknown are not supported. The compiler performs stricter type checking at development time.
• No runtime object layout changes: Dynamically adding/removing object properties is not allowed; object structure is determined at compile time.
• Restricted operator semantics: The unary plus operator + can only operate on numbers, not for string-to-number conversion.
• No Structural typing: Type compatibility is based on nominal typing, not structural typing.
• Use let instead of var: ArkTS requires let for variable declarations; var is not supported.

Code written by agents using generic TypeScript experience is highly likely to fail compilation or underperform on HarmonyOS. This skill provides offline reference documents (13 docs + INDEX under references/) which are offline copies of Huawei's official "ArkTS Language" documentation series, serving as the authoritative reference for ArkTS syntax/migration/performance/standard-library/state-management tasks.

When to Use This Skill

Follow this skill's workflow whenever any of the following conditions are met:

• The user requests writing or reviewing ArkTS code (syntax, type system, classes/interfaces/generics/enums)
• The user requests migrating TypeScript code to ArkTS (adaptation rules, adaptation cases)
• The user requests optimizing ArkTS code performance (high-performance programming practices)
• The user requests using the ArkTS standard library (XML/Buffer/JSON/container libraries)
• The user requests ArkTS concurrency programming (Promise/async-await/TaskPool/Worker/Sendable)
• The user requests ArkUI state management guidance (V1: @State/@Prop/@Link/@Provide/@Consume/@Observed/@ObjectLink; V2: @ObservedV2/@Trace/@Local/@Param)
• The user asks about differences between ArkTS and TypeScript
• The user requests ArkTS coding standards (naming, code formatting, comments)
• The user mentions arkts-no-* rules but needs syntax guidance rather than error fixes
• The user mentions ArkTS language features (@Concurrent, Sendable, container classes, etc.)

Do not force this skill onto "ArkTS compilation error fixes", "NDK/C++ interop", or "command-line build/deploy" scenarios — use the corresponding skills instead (see boundary below).

Boundary with Other Skills

This skill covers "ArkTS language syntax and style guidance", not "how to fix compilation errors", "how to write NDK code", or "how to invoke build commands". When ArkTS development tasks involve the following issues, cross-reference the corresponding skill:

Workflow (Follow Strictly)

1. Read the Index First, Then Decide Which Doc to Load

Before any ArkTS syntax/migration/performance task, you must read references/INDEX.md first. It provides the role of each of the 12 documents, reading paths by scenario, and key difference quick references — this prevents loading the entire reference directory into context.

2. Load the Corresponding Document by Task Type

When reading documents, prefer using Grep/Read with offset/limit to locate specific sections — do not read large files in their entirety at once.

3. Strictly Enforce Red Lines When Writing Code

Before writing or modifying ArkTS code, self-check the following high-frequency red lines (detailed rules are subject to the original documentation):

TS→ArkTS difference red lines:

• No any/unknown: Must use concrete types
• No runtime object layout changes: Cannot dynamically add/remove properties
• No as type assertions: Use explicit type declarations
• Unary + only for numbers: Use Number() or parseInt() for string-to-number conversion
• Use let instead of var: ArkTS does not support var
• Object literals must correspond to declared classes or interfaces: Cannot use anonymous object types

High-performance programming red lines:

• Use const for unchanging variables: Variables declared with let that are never modified should use const
• Avoid mixing integer and floating-point types: number type variables should not mix integers and floating-point values
• Avoid sparse arrays: Arrays should be initialized contiguously
• Avoid reassigning function parameters: Parameters should be treated as read-only
• Use ArkTS container classes instead of Array: ArrayList/HashMap/TreeMap, etc. offer better performance

When uncertain, search the original text in references/04-ts-to-arkts-migration-rules.md or 06-arkts-high-performance.md for the relevant red line before writing.

4. Cite the Source When Referencing Documents

When answering ArkTS syntax/migration/performance questions, include a citation at the end of the response, e.g.:

Per the "Mandatory Static Typing" section in references/04-ts-to-arkts-migration-rules.md.

5. Do Not Skip or Replace This Skill's Checks

Even if the user's code "looks like valid TypeScript", in the HarmonyOS context you must verify against this skill's red lines before answering — do not assume TypeScript knowledge can be directly applied to ArkTS.

TS→ArkTS Differences Quick Reference

High-Performance Programming Rules

Directory Structure

arkts-helper/
├── SKILL.md                                          # This file
└── references/
    ├── INDEX.md                                      # Must read first
    ├── 01-arkts-language-introduction.md             # ArkTS language introduction
    ├── 02-arkts-coding-style.md                      # ArkTS coding style
    ├── 03-ts-to-arkts-migration-background.md        # TS→ArkTS migration background
    ├── 04-ts-to-arkts-migration-rules.md             # TS→ArkTS migration rules
    ├── 05-ts-to-arkts-migration-cases.md             # TS→ArkTS migration cases
    ├── 06-arkts-high-performance.md                  # ArkTS high-performance programming
    ├── 07-arkts-stdlib-overview.md                   # ArkTS standard library overview
    ├── 08-arkts-xml-buffer-json.md                   # XML/Buffer/JSON extension libraries
    ├── 09-arkts-container-library.md                 # ArkTS container library
    ├── 10-arkts-concurrency-async.md                 # Async concurrency (Promise/async-await)
    ├── 11-arkts-concurrency-multithread.md           # Multi-thread concurrency & inter-thread communication
    ├── 12-arkts-cross-language-overview.md           # Cross-language interaction overview
    └── 13-arkts-state-management.md                  # ArkUI state management overview (V1/V2)

Documentation Source & Maintenance

• Upstream: Huawei Developer official site "Documentation Center › Application Development" series, under https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/:
  • introduction-to-arkts (ArkTS language introduction)
  • arkts-coding-style-guide (ArkTS coding style)
  • arkts-migration-background (migration background)
  • typescript-to-arkts-migration-guide (migration rules)
  • arkts-more-cases (migration cases)
  • arkts-high-performance-programming (high-performance programming)
  • arkts-utils-overview (standard library overview)
  • xml-generation-parsing-conversion + buffer + arkts-json (XML/Buffer/JSON)
  • containers + linear-container + nonlinear-container (container libraries)
  • async-concurrency-overview (async concurrency)
  • multithread-concurrency + interthread-communication (multi-thread concurrency)
  • arkts-cross-language-interaction (cross-language interaction)
  • arkts-state-management-overview (ArkUI state management V1/V2 overview)
• Documents are offline snapshots: 01-12 taken on 2026-07-20, 13 taken on 2026-08-29; each document includes the upstream URL and fetch timestamp at the top.
• To update to the latest version, re-run the fetch (use curl/WebFetch from the upstream URLs to overwrite files in references/); if expanding the file list, also update references/INDEX.md.
• ArkTS language specifications may change with HarmonyOS version updates; if uncertain about syntax, consult the latest official documentation.