@moon791017/neo-skills 1.0.1

package/skills/swift-ui/reference/anti-patterns.md

@@ -0,0 +1,52 @@
+# SwiftUI Anti-Patterns and Best Practices
+
+## 1. The "God View"
+**Problem**: A single view contains excessive functionality, leading to a `body` that exceeds 100 lines.
+**Impact**: Code becomes difficult to maintain, and performance decreases during re-rendering.
+**Recommendation**: Split the view into smaller, single-responsibility `struct` views.
+
+## 2. In-View Logic
+**Problem**: Writing complex conditional logic, mathematical calculations, or network calls within `body` or View Modifiers.
+**Impact**: View rendering becomes unstable and difficult to unit test.
+**Recommendation**: Move logic to a ViewModel (traditional projects) or Model (projects using `@Observable`).
+
+## 3. Excessive use of `AnyView`
+**Problem**: Frequently using `AnyView` to erase types.
+**Impact**: SwiftUI cannot optimize the view tree, leading to significant rendering performance issues.
+**Recommendation**: Prioritize the use of `@ViewBuilder`, `Group`, or `if-else`.
+
+```swift
+// Bad
+func content() -> AnyView {
+    if isTrue {
+        return AnyView(Text("True"))
+    } else {
+        return AnyView(Circle())
+    }
+}
+
+// Good
+@ViewBuilder
+func content() -> some View {
+    if isTrue {
+        Text("True")
+    } else {
+        Circle()
+    }
+}
+```
+
+## 4. Forced Unwrapping in `body`
+**Problem**: Using `!` to force unwrap optional types within `body`.
+**Impact**: The application will crash directly when rendering an incomplete state.
+**Recommendation**: Always use `if let` or `guard let` (within helper functions) to provide safe fallback content.
+
+## 5. Unnecessary `@State` Updates
+**Problem**: Modifying `@State` during the view rendering process (Side Effect).
+**Impact**: Leads to update cycles or infinite loop crashes.
+**Recommendation**: Only modify state when triggered by actions (e.g., `.onAppear`, `onTapGesture`).
+
+## 6. Deprecated Navigation Patterns
+**Problem**: Still using `NavigationView` in iOS 16+ projects.
+**Impact**: Lacks support for modern data-driven navigation.
+**Recommendation**: Fully migrate to `NavigationStack` and `NavigationPath`.

package/skills/swift-ui/reference/coding-style.md

@@ -0,0 +1,46 @@
+# SwiftUI Coding Style and Naming Conventions
+
+## View Declaration
+- **View Name**: Should use `PascalCase` and be named after its functionality (e.g., `UserProfileView.swift`).
+- **Structs over Classes**: Views should always be defined as `struct` and conform to the `View` protocol.
+
+## View Body Structure
+- **Keep `body` Clean**: The `body` should not contain complex calculation logic, network requests, or data processing.
+- **Sub-view Deconstruction**:
+  - When the `body` exceeds 30-50 lines, it should be considered for splitting into independent sub-views.
+  - Prioritize using `struct` sub-views over computed properties (`var subview: some View`).
+
+## View Modifier Ordering
+The order of modifiers affects the rendering result. Follow this logical sequence:
+1. **Layout**: `frame`, `padding`, `layoutPriority`.
+2. **Effects**: `background`, `border`, `shadow`, `clipShape`, `opacity`.
+3. **Interaction**: `onTapGesture`, `onHover`.
+4. **Positioning**: `offset`, `position`.
+
+```swift
+// Good
+Text("Hello")
+    .frame(maxWidth: .infinity) // 1. Layout
+    .background(Color.blue)    // 2. Effects
+    .onTapGesture { ... }      // 3. Interaction
+
+// Bad
+Text("Hello")
+    .background(Color.blue)    // The background will follow the text only, not the frame
+    .frame(maxWidth: .infinity)
+```
+
+## State Management Naming
+- **Private State (@State)**: Should be marked as `private`.
+- **Two-way Binding (@Binding)**: Should be clearly named, reflecting the data it represents rather than the UI behavior.
+
+## Preview Patterns (iOS 17+)
+- Always use the `#Preview` macro for view development.
+- Provide mock data and ensure testing for Dark Mode and Dynamic Type.
+
+```swift
+#Preview {
+    UserProfileView(user: User.mock)
+        .preferredColorScheme(.dark)
+}
+```

package/skills/swift-ui/reference/patterns.md

@@ -0,0 +1,87 @@
+# Modern SwiftUI Patterns (iOS 16+)
+
+## 1. View Composition (Small Views)
+**Concept**: Splitting large UIs into multiple small views.
+**Advantages**: Clearer code, easier testing, and reduced Swift compilation time.
+
+```swift
+struct UserCard: View {
+    let user: User
+    var body: some View {
+        HStack {
+            UserAvatar(imageName: user.avatar)
+            UserInfoDetails(name: user.name, email: user.email)
+        }
+    }
+}
+```
+
+## 2. Modern Observation (iOS 17+)
+**Pattern**: Using the `@Observable` macro for state management.
+**Features**: Eliminates the need for `@Published` annotations, automatically tracks properties, and provides better rendering performance.
+
+```swift
+@Observable
+class AppState {
+    var count = 0
+}
+
+struct CounterView: View {
+    @State private var state = AppState()
+    var body: some View {
+        Button("Count: \(state.count)") { state.count += 1 }
+    }
+}
+```
+
+## 3. Custom View Modifiers
+**Purpose**: Encapsulating common styles or behaviors (e.g., standard button styles).
+**Advantages**: Provides a unified design language and reduces confusion within the view hierarchy.
+
+```swift
+struct BrandButtonModifier: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .padding()
+            .background(Color.blue)
+            .foregroundColor(.white)
+            .clipShape(Capsule())
+    }
+}
+
+extension View {
+    func brandButtonStyle() -> some View {
+        modifier(BrandButtonModifier())
+    }
+}
+```
+
+## 4. Modern Navigation (iOS 16+)
+**Recommendation**: Use `NavigationStack` combined with path binding (`Path Binding`).
+**Advantages**: Complete control over the navigation stack, supporting deep linking.
+
+```swift
+struct MainApp: View {
+    @State private var path = NavigationPath()
+    var body: some View {
+        NavigationStack(path: $path) {
+            List(Items) { item in
+                NavigationLink(value: item) { Text(item.name) }
+            }
+            .navigationDestination(for: Item.self) { item in
+                DetailView(item: item)
+            }
+        }
+    }
+}
+```
+
+## 5. ViewThatFits
+**Purpose**: Automatically select the appropriate layout across different device sizes (e.g., iPhone mini vs. iPhone Pro Max).
+
+```swift
+ViewThatFits {
+    HStack { ... } // Try first
+    VStack { ... } // Fallback here if width is insufficient
+}
+```