Vishwajit sharma

Hi, my name is Vishali Sherpa. I completed my engineering in 2015, and after that, I joined the IT sector as a front-end developer. I have expertise in HTML, CSS, JavaScript, jQuery, Bootstrap, and I've also learned React. Over the last four years, I've been particularly working on React projects. Apart from React, I have experience with NextGen's React Native, TypeScript, MongoDB, Express, and Notes. In the domains I've worked on, I have experience in ecommerce, healthcare, and HRMS. I've worked on these domains, and I'm working on them. So, that's a summary of my experience. I have a total of 5 and a half years of experience in front-end development, and more than 5 and a half years, with over 4 years of experience specifically in React.

When should components be connected directly to application state versus receiving data from parent components, especially in large React projects? So in large React projects, deciding whether a component should connect directly to the application state or receive data from its parent's component is an important architectural consideration. So what we can do is establish guidelines. The first is the global state versus the local state. Global state data needs to be accessible by many components across the application or data that should persist across various routes should be stored in a global state. Then we can have Redux, context API, or MobX. Local state is data that is specific to a particular component or a small set of components that doesn't need to be shared widely. Next is component reusability. Direct connection if a component is intended to be used in different parts of the application and requires data from the global state, it can connect directly to the global state. This makes the component more reusable because it doesn't depend on the parent component to pass down the required data. Then parent-provided data. If a component's data needs are specific to a particular context or a particular parent component, it is often better to receive data as props. This allows the parent component to manage data and pass down what is necessary earlier, leading to better encapsulation and easier testing. And performance considerations must be there. Direct connection is there. Parent-provided data. Separation of concerns must be there. Then testing and debugging should be there. So in conclusion, large projects require a balance between these two approaches. Key components that need to access global data or dispatch actions should connect directly to the state. In contrast, other components can remain dumb and receive data through props to keep the architecture clean and maintainable. Using patterns like Redux selectors, memoization, and React's Context API can also help with performance and maintainability regardless of the approach chosen.

What would be your approach to set up a GitHub actions workflow for continuous integration of a new feature in a React project is to automate testing, linting, and building of the project whenever changes are pushed to the repository, especially for new feature branches. So the first step is to create a workflow configuration file. In a React project, create a new directory called workflows and add a YAML file for the CI workflow. The breakdown of the workflow file involves specifying the events which trigger the workflow, such as push and pull requests. This is followed by jobs, which are the individual tasks that make up the workflow. Each job consists of steps, which are the actions that are executed in a specific order. The steps include checking out the code, installing dependencies, running tests, building the project, and caching node modules to speed up workflows. Additional considerations involve setting up environment variables, which can be stored in the GitHub repository settings under secrets and variables actions or directly in the workflow file using the END key. Notifications can also be set up for CI status via Slack or email. Testing the workflow is crucial to ensure that it is working as expected. Once the workflow file is set up, it should be pushed to the repository. GitHub actions will automatically run the CI workflow on the specified events, improving the workflow, deployments, code coverage, end-to-end testing, and security checks. This setup provides a basic CI pipeline for a React project, ensuring that new features are continuously integrated and validated through automated testing and build processes.

If a project requires extensive use of SBG and interactive animations. How would you structure your React components to efficiently manage these assets? So when working with a React project that extensively uses SVGs and interactive animations, it's important to structure your components and manage assets efficiently. First, is you should organize the SVGs. SVG as a component. For SVGs that require interaction or animation, import them as React components. This allows for greater flexibility and ease of use. Tools like SVGR can convert SVG files into React components, allowing you to use them directly in GSX. Then we have the centralized asset management to store SVG files in a dedicated directory, then create an index.js file in the SVG directory to export all SVG components. This provides a single import source, simplifying imports throughout the project. Then the component structure for animations and SVGs should be reusable SVG components. Create reusable components for commonly used SVGs with animation or interaction logic encapsulated within the component. Use props to customize the SVG appearance or behavior. Then animation components for complex animations consider libraries, create higher order components or hooks for animations, and then apply them to SVG components. For efficient SVG management, optimize SVG files, like, for tools like SVGO to reduce file size and remove unnecessary metadata. Consider inlining small SVGs directly to component files for better performance. Lazy load larger, infrequently used SVGs for improved initial load performance. Use libraries like React Lazy and Suspense for this purpose. Use context or state management for interaction state and use CSS-in-JS libraries like Emotion for styling and animations. Efficiently managing SVGs and animations in the React project involves a combination of best practices, including optimizing SVGs using appropriate tools for animation, and maintaining a clean separation of concerns between presentation and logic. This approach not only ensures smooth performance, but also makes the project easier to maintain and extend.

TypeScript enhances error detection over plain JavaScript in the development process. So TypeScript enhances error detection and overall development experience in several key ways compared to plain JavaScript. 1st is the static type checking. TypeScript introduces static typing to JavaScript, meaning types are checked and compiled at time. This helps catch type-related errors the code runs, unlike JavaScript where such errors may only appear at runtime. In JavaScript, the above error would only manifest when the function is executed, potentially leading to runtime errors. TypeScript catches this mistake during development. Then the enhanced IDE support and auto-completion TypeScript's type system allows for richer IDE support, including accurate auto-completion, inline documentation, and type inference. This lets improve developer productivity and reduces errors caused by incorrect function usage or property access. Then the type inference. TypeScript can infer types even when they are not explicitly defined. This helps detect errors while minimizing the need for verbose type annotations. Structural type system. TypeScript uses a structural type system which checks the types based on their structure rather than explicit declaration. This is particularly useful when dealing with complex objects and ensures that object properties match the expected structure. Then optional and union types are there with TypeScript supports, which helps model more complex data structures and potential values leading to better error detection. The interfaces and type aliases that promote consistency and reduce the likelihood of errors, strict and null checking, like undefined and null, compile-time error detection. Then TypeScript's type system provides a robust framework for detecting errors at compile time, improving code reliability, maintainability, and overall development efficiency. By catching errors early and providing better tooling support, TypeScript helps developers write safer and more predictable code compared to plain JavaScript.

How do you structure your GitLab CICD pipeline to efficiently handle multiple feature branches as well as staging and production environments in a project? As well as staging and production environments in a project. So structuring a GitLab CICD pipeline to efficiently manage multiple feature branches along with staging and production environments in a real project involves setting up a well-defined pipeline with different stages and jobs. So the basic pipeline structure is, you should create a basic pipeline structure, stages, and jobs. The build stage is there. Install dependencies, artifacts, test stage is there, run tests and linters to ensure code quality. Only this job requires for branches and tags. The deploy stage, define different end deployments jobs for staging and production environments. These jobs should only run for specific branches or tags. Then, environment-specific configurations are only applied when manual environment-specific configurations are defined to handle different configurations for staging and production. You can use environment variables, store sensitive information securely in GitLab, CICD variables, and handle feature branches. For feature branches, the pipeline should build, test, and possibly deploy to a staging environment for testing. You can automate deployments to temporary development or subdomains if necessary, dynamic feature environments, monitoring, and rollback. Monitor deployments and have a rollback mechanism in place. GitLab provides an environment dashboard to track deployments and rollbacks. Then, approval and notification using GitLab's built-in approval system for production deployments, set up notifications for pipeline status updates. The best practices should be testing in CICD, security, and documentation. So by following these steps, we can set up a robust GitLab CICD pipeline that efficiently handles multiple feature branches, staging, and production environments, ensuring a smooth and controlled development and deployment process.

Can you describe what happened in the schedule for handle data is called with null or undefined argument? How would you factor this in the data? No undefined argument, okay. So if the null or undefined data is passed, then data.trim() because data.trim() is a function specific to strings only. So in case of null or undefined, it will give you an error. So what we can do is use optional chaining here. So data?.trim(). So if the data exists, then the trim function should apply. Otherwise, it should not apply. So that's the most important thing which we can do here. Null and undefined should not be counted. An else condition can be used, otherwise, the most beautiful thing is using optional chaining.

In the SaaS, could you explain the use of 'and' and identify the potentials that might have missed another dot button inside the scope? Okay, so inside the container button, there is and hover of that button, the color is background color, is converted to dark blue. So, is just like, you know, the CSS hover class or hover effect to add in the SaaS we use. And so in any component, if the end is there, so it would be applied to that immediate parent component only. In that case, the button is the immediate parent component. So what would happen if we nest another button inside the scope? If we nest another button, then that hover effect would be applied to that nested button also. So in that case, it would be a CSS issue to nest another button. So we should not nest another button inside that scope because the hover effect will be applied automatically to that button also, which we may not want.

Present a pattern or approach for ensuring the maintainability of CSS styles in a large React application using SASS. Maintaining CSS ties in a large React application can become challenging as the project grows. So, using SASS with a well-structured approach can significantly improve maintainability, scalability, and consistency. Here's a pattern we can follow. The first is the modular file structure. Organize your SASS files in a modular and hierarchical structure. This helps in maintaining a clear separation of concerns and makes it easier to find and update the styles. Next is using variables. Define CSS variables for colors, font, spacing, etc., in a variables.scss file, which decentralizes the values and makes it easy to update them across the entire application. Use mixins and functions to avoid repetitive code and handle complex styling logic. Store these in _mixins.scss and _functions.scss, and keep component-level styles in their corresponding SASS files in the components folder. For each React component, create a corresponding SASS file in the components folder. This keeps components styled, scoped, and organized. Next is the BEM naming convention, which helps maintain a clear and consistent style across the project. Then, manage themes in the themes folder, which allows you to switch themes by simply changing the imported theme file. Keep global styles and utility classes in separate files and include them as needed. Import all the SASS files in a logical order. Link to style guidelines and documentation to ensure everyone on the team is on the same page. By organizing your SASS files in a modular structure using consistent naming conventions like BEM and leveraging SASS features like variables, mixins, includes, and functions, you can significantly enhance the maintainability of CSS files in a large React application. This approach not only improves readability and scalability but also facilitates easier debugging and collaboration among team members.

Describe the approach you would take to use sketch design files to automate the component regeneration process. So in a component regeneration process, we can sketch the design using Figma. Canva tool is there. So there are multiple tools. I don't have an idea about it.

I had optimized the React application on this. So I have used React lazy loading for optimizing the first FCP and LCP. Then I have used image optimization, images have been used for optimizing, then optimizing the Webpack. I have used the Rollup bundler. I have used these things.