Implement custom style editor support for NaverMapView (#161)

* docs: standardize claude pattern keywords and update documentation

- Standardize keywords in all claude pattern files for consistency
- Update CLAUDE.md pattern list table with new keyword format
- Update claude commands and settings configuration
- Update package dependencies

* docs: complete pattern keyword standardization

- Finalize keyword updates for remaining pattern files
- Ensure consistent hyphenated keyword format across all patterns
- Update CLAUDE.md with final pattern list table

* feat: add expo example as submodule

- Add mym0404/naver-map-expo-example as git submodule
- Located at expoexample/ directory for easy access
- Provides Expo SDK 54 integration example with full map features

* feat: implement custom style editor support for NaverMapView

## Features
- Add customStyleId prop to apply Naver Style Editor styles
- Add onCustomStyleLoaded callback for successful style loading
- Add onCustomStyleLoadFailed callback with error message
- Support both iOS and Android platforms with native implementations

## Implementation Details
- TypeScript: Added new props to NaverMapViewProps interface
- Native Spec: Updated codegen specification with new props and events
- iOS: Implemented setCustomStyleId with load/fail handlers using NMFMapView
- Android: Implemented setCustomStyleId with OnCustomStyleLoadCallback
- Example: Added toggle button and test with style ID bf462d9f-fa82-413d-ab7c-df9c5e3c9f7f
- Docs: Added custom style guide in English and Korean

## Testing
- Android build: ✅ Successful (gradlew assembleDebug)
- Example app: Added "Custom Style" toggle for testing
- Error handling: Proper error message parsing for both platforms

## Breaking Changes
None - all new props are optional

## References
- Style Editor: https://style-editor.map.naver.com

* docs: add custom-style to Korean meta.json

* fix: improve custom style API for iOS implementation

- Remove unused _isRecycled flag
- Fix setCustomStyleId method handler parameter names (LoadHandler/FailHandler)
- Use local mapView variable for cleaner code
- Simplify style clearing when customStyleId is nil

* chore: update example iOS dependencies

- Update library version from 2.5.6 to 2.6.1
- Update ReactCodegen checksums

* docs: remove completed custom map styling milestone

Remove custom map styling section from milestone documentation as the feature has been implemented

* docs: remove redundant pattern detection section from CLAUDE.md

Clean up duplicate keyword detection and command intent recognition instructions

Author: mym0404

.claude/commands/page-refer.md

@@ -15,20 +15,20 @@ This command retrieves saved session histories to restore context from previous
 ### CLI Commands Used
 
 ```bash
-npx -y cc-self-refer page search <keyword> # Search pages by keyword
-npx -y cc-self-refer page list             # List all pages
-npx -y cc-self-refer page view <id>        # View specific page
+npx cc-self-refer page search <keyword> # Search pages by keyword
+npx cc-self-refer page list             # List all pages
+npx cc-self-refer page view <id>        # View specific page
 ```
 
 ### Command Arguments
 - `id`: Page ID number (for view command)
 - `keyword`: Search keyword or phrase (for search command)
 
 ### Expected Workflow
-1. Search for relevant session pages using `npx -y cc-self-refer page search <keyword>` (keyword is generated by claude code from user input)
+1. Search for relevant session pages using `npx cc-self-refer page search <keyword>` (keyword is generated by claude code from user input)
 2. Check search results:
   - If search result contains sufficient session context, use that information directly
-  - If search result only shows summary/metadata, use `npx -y cc-self-refer page view <id>` for complete session content
+  - If search result only shows summary/metadata, use `npx cc-self-refer page view <id>` for complete session content
 3. **APPLY the session knowledge** to current development work:
   - Reference previous decisions and architectural choices
   - **Focus on continuing the development work based on past session context**

.claude/commands/page-save.md

@@ -13,7 +13,7 @@ This commadns run `cc-self-refer page create` commands with title
 ### CLI Command Used
 
 ```bash
-npx -y cc-self-refer page create "<title>"
+npx cc-self-refer page create "<title>"
 ```
 
 ### Command Arguments

.claude/commands/pattern-create.md

@@ -13,14 +13,29 @@ Extract code snippet or common pattern in project and run cc-self-refer pattern
 ### CLI Command Used
 
 ```bash
-npx -y cc-self-refer pattern create "<pattern-name>" "<keyword1>,<keyword2>,<keyword3>" "<language>" "<explanation>" <<'EOF'
+npx cc-self-refer pattern create "<pattern-name>" "<keyword1>,<keyword2>,<keyword3>" "<language>" "<explanation>" <<'EOF'
 <pattern-content>
 EOF
 ```
 
 ### Command Arguments
 - `pattern-name`: Name of the code pattern, Don't include `pattern` in the name
-- `keywords`: Comma-separated **specific** keywords for pattern search and CLAUDE.md listing (required). Use only unique, pattern-specific terms. Avoid generic language names (javascript, nodejs, python) or broad categories. Focus on the distinctive aspects of the pattern (e.g., "commander", "subcommands", "cli-options" rather than "javascript, nodejs, cli")
+- `keywords`: Comma-separated keywords for pattern search (3-5 keywords recommended)
+  - **DO**: Use conceptual terms that describe the pattern's purpose and functionality
+  - **DO**: Include technology-specific terms when they're central to the pattern (e.g., "fabric", "turbo-module", "codegen")
+  - **DO**: Focus on what the pattern DOES, not implementation details
+  - **DON'T**: Use generic language names alone (javascript, typescript, python)
+  - **DON'T**: Use specific class/method names unless they're widely recognized APIs
+  - **DON'T**: Over-specify with implementation details
+
+  Examples:
+  - ✅ GOOD: "fabric,component,props,events" (describes pattern purpose)
+  - ✅ GOOD: "commands,imperative,async" (describes functionality)
+  - ✅ GOOD: "validation,error-handling,schemas" (describes what it does)
+  - ❌ BAD: "javascript,nodejs,function" (too generic)
+  - ❌ BAD: "RCTViewComponentView,updateProps,initWithFrame" (too specific - API names)
+  - ❌ BAD: "ios,objective-c,native" (only platform/language identifiers)
+
 - `language`: Programming language (e.g., javascript, typescript, python, go, rust)
 - `explanation`: Brief explanation (1-2 sentences) of what this pattern does and when to use it
 - `pattern-content`: Complete code snippet or pattern content
@@ -143,7 +158,7 @@ Claude will:
 2. Generate <formatted content> with the above rules.
 3. Execute: 
    ```bash
-   npx -y cc-self-refer pattern create "api-error-handler" "error,handler,api,utilities" "typescript" "Utility pattern for handling API errors in TypeScript applications with proper error typing." <<'EOF'
+   npx cc-self-refer pattern create "api-error-handler" "error,handler,api,utilities" "typescript" "Utility pattern for handling API errors in TypeScript applications with proper error typing." <<'EOF'
    <formatted content>
    EOF
    ```

.claude/commands/pattern-use.md

@@ -14,23 +14,23 @@ Retrieve and apply code patterns with `cc-self-refer pattern search` command
 
 ```bash
 # Search for patterns first
-npx -y cc-self-refer pattern search <keyword>
+npx cc-self-refer pattern search <keyword>
 
 # View specific pattern
-npx -y cc-self-refer pattern view <id>
+npx cc-self-refer pattern view <id>
 
 # List all patterns
-npx -y cc-self-refer pattern list
+npx cc-self-refer pattern list
 ```
 
 ### Command Arguments
 - `id_or_keyword`: Pattern ID number or search keyword
 
 ### Expected Workflow
-1. Search for relevant patterns using `npx -y cc-self-refer pattern search`
+1. Search for relevant patterns using `npx cc-self-refer pattern search`
 2. Check search results:
   - If search result contains full pattern content, use that content directly
-  - If search result only shows summary/metadata, use `npx -y cc-self-refer pattern view <number>` for complete content
+  - If search result only shows summary/metadata, use `npx cc-self-refer pattern view <number>` for complete content
 3. **IMPLEMENT the actual code** using the printed content:
   - Apply the pattern's architectural principles and design decisions
   - **Focus on implementing working code, not just creating examples or documentation**

.claude/commands/plan-create.md

@@ -16,7 +16,7 @@ This command initiates a comprehensive implementation planning process through e
 
 ```bash
 # Create the implementation plan after planning:
-npx -y cc-self-refer plan create "<plan-title>" <<'EOF'
+npx cc-self-refer plan create "<plan-title>" <<'EOF'
 <plan-content>
 EOF
 ```
@@ -26,13 +26,44 @@ EOF
 ## Interactive Planning Process
 
 **Simple Workflow:**
-1. Ask what the user wants to plan
-2. Have a conversation to understand details
-3. Create the plan with CLI command
+1. Load existing patterns for context
+2. Ask what the user wants to plan
+3. Have a conversation to understand details (avoiding questions about existing patterns)
+4. Create the plan with CLI command (referencing patterns when applicable)
+
+**MANDATORY: Load Patterns Before Planning**
+
+**First, load all existing patterns into context:**
+```bash
+# Load pattern list
+npx cc-self-refer pattern list
+
+# Search for relevant patterns based on initial understanding
+npx cc-self-refer pattern search "<relevant-keywords>"
+
+# View specific patterns that might be useful
+npx cc-self-refer pattern view <pattern-id>
+```
+
+**WHY THIS MATTERS:**
+- Avoid asking questions already answered in patterns
+- Reference existing solutions in the implementation plan
+- Use established code templates and architectures
+- Maintain consistency with project conventions
+
+**PATTERN USAGE GUIDELINE:**
+- When writing implementation sections, actively consider if existing patterns apply
+- If a pattern matches the implementation need → Add "Use Pattern #[N]" inline
+- If no pattern exists → Write the implementation details normally
+- Don't force pattern usage where it doesn't naturally fit
+- Examples of when to reference patterns:
+  - Component structure matches existing pattern → "Use Pattern #[N] for component template"
+  - API client implementation exists → "Use Pattern #[N] for API integration"
+  - Error handling pattern available → "Use Pattern #[N] for error handling"
 
 **MANDATORY: Infinite Interactive Dialogue Process**
 
-**Start by asking:**
+**Start by asking (AFTER loading patterns):**
 ```
 What would you like to plan?
 
@@ -45,26 +76,29 @@ Please describe:
 **CRITICAL: After every user response, analyze what implementation details are still missing and ask deeper questions. NEVER stop asking until you know exactly how to implement everything.**
 
 **Self-Assessment Questions - Ask yourself after each user response:**
+- "Can any existing patterns solve this?" → Check patterns first
 - "What files exactly need to be created or modified?"
 - "What specific code changes are required?"
 - "What dependencies need to be installed?"
 - "What configuration changes are needed?"
 - "How will this integrate with existing code?"
 - "What testing approach should be used?"
+- "Which patterns should be referenced in the plan?"
 
-**Continuous Implementation Deep-Dive Pattern:**
-- If user says "add authentication" → Ask: Which files handle auth? What database changes? JWT or sessions? Middleware needed? Registration flow? Password reset?
-- If user says "improve performance" → Ask: What specific bottlenecks? Which components are slow? Database queries? Frontend rendering? API endpoints? Caching strategy?
-- If user says "refactor components" → Ask: Which exact components? What's the new structure? How to maintain backwards compatibility? Migration steps?
+**Continuous Implementation Deep-Dive Pattern (Skip if covered by patterns):**
+- If user says "add authentication" → First check: Any auth patterns exist? If not, ask: Which files handle auth? What database changes? JWT or sessions? Middleware needed? Registration flow? Password reset?
+- If user says "improve performance" → First check: Any performance patterns exist? If not, ask: What specific bottlenecks? Which components are slow? Database queries? Frontend rendering? API endpoints? Caching strategy?
+- If user says "refactor components" → First check: Any refactoring patterns exist? If not, ask: Which exact components? What's the new structure? How to maintain backwards compatibility? Migration steps?
 
-**Keep Digging Until You Know:**
-- Exact file paths that need changes
-- Specific functions/components to create/modify
+**Keep Digging Until You Know (Unless Pattern Already Provides):**
+- Exact file paths that need changes (or pattern references)
+- Specific functions/components to create/modify (or pattern usage)
 - Complete dependency list with versions
 - Step-by-step implementation sequence
 - All configuration changes required
 - Comprehensive testing strategy
 - Success criteria with measurable outcomes
+- Which patterns to apply and where
 
 **Signs You Need More Implementation Details:**
 - You don't know exact file paths → ASK MORE
@@ -79,7 +113,7 @@ Please describe:
 After complete implementation understanding, create the plan using:
 
 ```bash
-npx -y cc-self-refer plan create "<plan-title>" <<'EOF'
+npx cc-self-refer plan create "<plan-title>" <<'EOF'
 <plan-content>
 EOF
 ```

.claude/commands/plan-resolve.md

@@ -38,7 +38,7 @@ This command facilitates comprehensive execution of strategic plans by:
 
 ```bash
 # Step 1: Load the plan for implementation reference
-npx -y cc-self-refer plan view <id_or_keyword> 
+npx cc-self-refer plan view <id_or_keyword> 
 ```
 
 ### Command Arguments

.claude/commands/spec-refer.md

@@ -15,21 +15,21 @@ This command retrieves stored project specifications to restore development cont
 ### CLI Commands Used
 
 ```bash
-npx -y cc-self-refer spec search <keyword> # Search specs by keyword
-npx -y cc-self-refer spec list             # List all specs
-npx -y cc-self-refer spec view <id>        # View specific spec
+npx cc-self-refer spec search <keyword> # Search specs by keyword
+npx cc-self-refer spec list             # List all specs
+npx cc-self-refer spec view <id>        # View specific spec
 ```
 
 ### Command Arguments
 - `id`: Spec ID number (for view command)
 - `keyword`: Search keyword or phrase (for search command)
 
 ### Expected Workflow
-1. Search for relevant specifications using `npx -y cc-self-refer spec search <keyword>` (keyword is generated by claude code from user input)
+1. Search for relevant specifications using `npx cc-self-refer spec search <keyword>` (keyword is generated by claude code from user input)
 2. Check search results:
   - If search result contains sufficient spec context, use that information directly
-  - If search result only shows summary/metadata, use `npx -y cc-self-refer spec view <id>` for complete spec content
+  - If search result only shows summary/metadata, use `npx cc-self-refer spec view <id>` for complete spec content
 3. **APPLY the specification knowledge** to current development work:
   - Reference project requirements and constraints
   - **Focus on implementing features based on spec context**
-  - Integrate the spec knowledge directly into current task execution
+  - Integrate the spec knowledge directly into current task execution

.claude/commands/spec.md

@@ -16,7 +16,7 @@ This command initiates a comprehensive specification creation process through ex
 
 ```bash
 # Create each specification file after planning:
-npx -y cc-self-refer spec create "<spec-title>" <<'EOF'
+npx cc-self-refer spec create "<spec-title>" <<'EOF'
 <spec-content>
 EOF
 ```
@@ -80,7 +80,7 @@ Execute CLI commands to create each specification:
 
 ```bash
 # Example for e-commerce platform specifications
-npx -y cc-self-refer spec create "E-commerce Product Vision" <<'EOF'
+npx cc-self-refer spec create "E-commerce Product Vision" <<'EOF'
 # E-commerce Platform Product Vision
 
 ## Executive Summary
@@ -91,7 +91,7 @@ npx -y cc-self-refer spec create "E-commerce Product Vision" <<'EOF'
 ...
 EOF
 
-npx -y cc-self-refer spec create "User Personas and Journeys" <<'EOF'
+npx cc-self-refer spec create "User Personas and Journeys" <<'EOF'
 # User Personas and Customer Journeys
 
 ## Primary Personas

.claude/patterns/001-fabric-native-component.md

@@ -1,5 +1,5 @@
 ---
-keywords: fabric, native, component, react-native, codegen
+keywords: fabric,component,props,events,codegen
 language: typescript
 explanation: Defines React Native Fabric component using codegenNativeComponent with TypeScript props interface
 ---

.claude/patterns/002-codegen-native-commands.md

@@ -1,5 +1,5 @@
 ---
-keywords: codegen, native, commands, react-native, async, sync
+keywords: commands,imperative,async,native-methods,codegen
 language: typescript
 explanation: Defines imperative native methods using codegenNativeCommands for async/sync operations
 ---