TheBushidoCollective/han - Page 3

react-native-web-core

Use when working with React Native Web projects. Provides core concepts, components, and cross-platform patterns for building web applications with React Native.

react-native-web-navigation

Use when implementing navigation in React Native Web projects. Provides patterns for React Navigation, deep linking, and web-specific routing.

react-native-web-performance

Use when optimizing React Native Web performance. Provides patterns for code splitting, bundle optimization, memoization, and web-specific performance improvements.

react-native-web-styling

Use when styling React Native Web components. Provides patterns for StyleSheet API, platform-specific styles, responsive design, and theming.

react-native-web-testing

Use when testing React Native Web applications. Provides patterns for Jest, React Native Testing Library, component testing, and web-specific testing strategies.

react-context-patterns

Use when React Context patterns for state management. Use when sharing state across component trees without prop drilling.

react-hooks-patterns

Use when React Hooks patterns including useState, useEffect, useContext, useMemo, useCallback, and custom hooks. Use for modern React development.

react-performance

Use when React performance optimization including memoization, lazy loading, and virtualization. Use when optimizing React applications.

reactflow-custom-nodes

Use when creating custom React Flow nodes, edges, and handles. Covers custom node components, resizable nodes, toolbars, and advanced customization.

reactflow-fundamentals

Use when building node-based UIs, flow diagrams, workflow editors, or interactive graphs with React Flow. Covers setup, nodes, edges, controls, and interactivity.

relay-fragments-patterns

Use when relay fragment composition, data masking, colocation, and container patterns for React applications.

relay-mutations-patterns

Use when relay mutations with optimistic updates, connections, declarative mutations, and error handling.

relay-pagination

Use when relay pagination with cursor-based pagination, infinite scroll, load more patterns, and connection protocols.

svelteflow-custom-nodes

Use when creating custom Svelte Flow nodes, edges, and handles. Covers custom node components, resizable nodes, toolbars, and advanced customization.

svelteflow-fundamentals

Use when building node-based UIs, flow diagrams, workflow editors, or interactive graphs with Svelte Flow. Covers setup, nodes, edges, controls, and interactivity.

vue-component-patterns

Use when Vue component patterns including props, emits, slots, and provide/inject. Use when building reusable Vue components.

vue-composition-api

Use when Vue 3 Composition API with reactive refs, computed, and composables. Use when building modern Vue 3 applications.

vue-reactivity-system

Use when Vue reactivity system with refs, reactive, computed, and watchers. Use when managing complex state in Vue applications.

zustand-advanced-patterns

Use when implementing advanced Zustand patterns including transient updates, subscriptions with selectors, store composition, and performance optimization techniques.

zustand-middleware

Use when implementing Zustand middleware for persistence, dev tools, immutability, and other enhanced store functionality. Covers persist, devtools, immer, and custom middleware.

zustand-store-patterns

Use when creating and managing Zustand stores for React state management. Covers store creation, selectors, actions, and basic usage patterns.

zustand-typescript

Use when working with Zustand in TypeScript projects. Covers type-safe store creation, typed selectors, and advanced TypeScript patterns with Zustand.

c-data-structures

Use when implementing data structures in C including arrays, linked lists, trees, and hash tables with manual memory management.

c-memory-management

Use when managing memory in C programs with malloc/free, pointers, and avoiding common memory safety pitfalls.

c-systems-programming

Use when writing low-level system software in C requiring file I/O, process management, signals, and system calls.

cpp-modern-features

Use when working with modern C++ codebases requiring features from C++11 to C++23 including lambdas, move semantics, ranges, and concepts.

cpp-smart-pointers

Use when managing memory safely in C++ with smart pointers including unique_ptr, shared_ptr, weak_ptr, and RAII patterns.

cpp-templates-metaprogramming

Use when creating generic and type-safe C++ libraries with templates, SFINAE, concepts, and compile-time metaprogramming.

crystal-concurrency

Use when implementing concurrent programming in Crystal using fibers, channels, and parallel execution patterns for high-performance, non-blocking applications.

crystal-engineer

Use when working with Crystal language development including WebSocket communication, TLS/SSL configuration, HTTP frameworks, ORM operations, and high-performance concurrent systems.

crystal-macros

Use when implementing compile-time metaprogramming in Crystal using macros for code generation, DSLs, compile-time computation, and abstract syntax tree manipulation.

csharp-async-patterns

Use when C# async/await patterns including Task, ValueTask, async streams, and cancellation. Use when writing asynchronous C# code.

csharp-linq

Use when lINQ query and method syntax, deferred execution, and performance optimization. Use when querying collections in C#.

csharp-nullable-types

Use when C# nullable reference types, null safety patterns, and migration strategies. Use when ensuring null safety in C# code.

elixir-ecto-patterns

Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.

elixir-otp-patterns

Use when Elixir OTP patterns including GenServer, Supervisor, Agent, and Task. Use when building concurrent, fault-tolerant Elixir applications.

elixir-pattern-matching

Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.

erlang-concurrency

Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.

erlang-distribution

Use when erlang distributed systems including node connectivity, distributed processes, global name registration, distributed supervision, network partitions, and building fault-tolerant multi-node applications on the BEAM VM.

erlang-otp-behaviors

Use when oTP behaviors including gen_server for stateful processes, gen_statem for state machines, supervisors for fault tolerance, gen_event for event handling, and building robust, production-ready Erlang applications with proven patterns.