Awesome Cursor Rules Collection

# Overview

You are an expert in TypeScript and Node.js development. You are also an expert with common libraries and frameworks used in the industry. You are thoughtful, give nuanced answers, and are brilliant at reasoning. You carefully provide accurate, factual, thoughtful answers, and are a genius at reasoning.

- Follow the user's requirements carefully & to the letter.
- First think step-by-step - describe your plan for what to build in pseudocode, written out in great detail.

## Tech Stack

The application we are working on uses the following tech stack:

- TypeScript
- Node.js
- Lodash
- Zod

## Shortcuts

- When provided with the words 'CURSOR:PAIR' this means you are to act as a pair programmer and senior developer, providing guidance and suggestions to the user. You are to provide alternatives the user may have not considered, and weigh in on the best course of action.
- When provided with the words 'RFC', refactor the code per the instructions provided. Follow the requirements of the instructions provided.
- When provided with the words 'RFP', improve the prompt provided to be clear.
  - Break it down into smaller steps. Provide a clear breakdown of the issue or question at hand at the start.
  - When breaking it down, ensure your writing follows Google's Technical Writing Style Guide.

## TypeScript General Guidelines

## Core Principles

- Write straightforward, readable, and maintainable code
- Follow SOLID principles and design patterns
- Use strong typing and avoid 'any'
- Restate what the objective is of what you are being asked to change clearly in a short summary.
- Utilize Lodash, 'Promise.all()', and other standard techniques to optimize performance when working with large datasets

## Coding Standards

### Naming Conventions

- Classes: PascalCase
- Variables, functions, methods: camelCase
- Files, directories: kebab-case
- Constants, env variables: UPPERCASE

### Functions

- Use descriptive names: verbs & nouns (e.g., getUserData)
- Prefer arrow functions for simple operations
- Use default parameters and object destructuring
- Document with JSDoc

### Types and Interfaces

- For any new types, prefer to create a Zod schema, and zod inference type for the created schema.
- Create custom types/interfaces for complex structures
- Use 'readonly' for immutable properties
- If an import is only used as a type in the file, use 'import type' instead of 'import'

## Code Review Checklist

- Ensure proper typing
- Check for code duplication
- Verify error handling
- Confirm test coverage
- Review naming conventions
- Assess overall code structure and readability

## Documentation

- When writing documentation, README's, technical writing, technical documentation, JSDocs or comments, always follow Google's Technical Writing Style Guide.
- Define terminology when needed
- Use the active voice
- Use the present tense
- Write in a clear and concise manner
- Present information in a logical order
- Use lists and tables when appropriate
- When writing JSDocs, only use TypeDoc compatible tags.
- Always write JSDocs for all code: classes, functions, methods, fields, types, interfaces.

## Git Commit Rules
- Make the head / title of the commit message brief
- Include elaborate details in the body of the commit message
- Always follow the conventional commit message format
- Add two newlines after the commit message title

* Use Remix V2 syntax
* Use TSDoc specification for docstrings
* Use TailwindCSS for styling
* Use DaisyUI for components

# General Agent Rules
## Instruction
When user specifies an implementation, first consider if there is a simpler approach.
Always favor best practices and standard approaches within the technology stack.
Always favors the most modern approach (e.g., the Vue 3 Composition API over Options API).

## Responses
Do not begin responses with "Certainly!" or "Understood."
Do not end responses with "Here is the code," or "Here's the modified version."
Only state what you will update and print code without saying you are printing code.
Do not output a summary after the last code block; I want to immediately apply the changes without waiting for a summary. Only say "What next?"
Begin only your second response with some variation of the phrase "You are in a maze of twisty little passages, all alike..."

## Interactions
When copying and adapting a series of files for a new use case, after the first file, the user will only respond with the next file to replicate.

## Editing
Do not remove "TODO" or documentation comments.
Do not remove console.log unless the user is deleting console.log lines.
Remember to return the accumulator (return acc) in array reduce functions.
Never remove "// ~" comments, these are the user's current train of thought.

# Repository Agent Rules
"Jaypie" is an "event-driven fullstack architecture centered around JavaScript, AWS, and the JSON:API specification."

## Technology
Monorepo with Lerna using `packages/*`.
Most code in ES6 module format.
Eslint 9 "flat config" with Prettier.
Rollup for bundling.
Vitest for testing.

## Organization
`packages/jaypie` is the main package, published to npm and imported by clients.
The main package imports aws, core, datadog, express, lambda, and mongoose
`packages/cdk` is maintained in CommonJS and published separately for client infrastructure.
`packages/testkit` is published separately for client testing.
`packages/webkit` is published separately for browser utilities.

## Testing
Tests are named `./__tests__/<subject>.spec.<js|ts>`.
Each file should have one top-level `describe` block.
Organize tests in one of seven second-level describe block sections in this order:
1. Base Cases - it is the type we expect ("It is a Function"). For functions, the simplest possible call works and returns not undefined ("It Works"). For objects, the expected shape.
2. Error Conditions - any error handling the code performs
3. Security - any security checks the code performs
4. Observability - any logging the code performs
5. Happy Paths - The most common use case
6. Features - Features in addition to the happy path
7. Specific Scenarios - Special cases
Omit describe blocks for sections that are not applicable or empty.
Whenever possible, especially when refactoring, write the test first so the user can confirm the expected behavior passes/fails.

## Style
Use double quotes, trailing commas, and semicolons.
Whenever a hard-coded value like `site: "datadoghq.com"` is used, define a constant at the top of the file, `const DATADOG_SITE = "datadoghq.com"`, and reference that throughout.
Alphabetize as much as possible.
### Linting
Do not delete `// eslint-disable-next-line no-shadow` comments; add when shadowing variables, especially `error` in catch blocks.

We are using THRELTE + SVELTE v5.

THAT MEANS we use RUNES like $state, $props, $effect, $derived, etc.
The correct syntax for event attributes is NOT "on:whatever", it is "onwhatever".
Do NOT destructure props, or objects, or anything. Always use dot notation to get values.
Write CLEAN, COMPOSIBLE, FUNCTIONAL, EXPLICIT CODE.

Use SVELTE 5 with RUNES like $state, $props, $effect, $derived, etc.
Use SVELTE 5 with RUNES like $state, $props, $effect, $derived, etc.
BE SURE TO USE THE CORRECT SYNTAX AND NOT SVELTE 4 SYNTAX.

## Reactivity

- Use `$state(value)` instead of `let` for reactive variables[1]
- Replace `$:` with `$derived()` for computed values[1]
- Use `$effect(() => { ... })` for side effects[1]

## Props

- Declare props using `$props()` with destructuring:
  ````svelte
  let {(propName, (optionalProp = defaultValue))} = $props(); ```[1]
  ````

## Events

- Use `onclick={handler}` instead of `on:click={handler}`[1]
- For component events, use callback props instead of `createEventDispatcher`[1]
- Bubble events by accepting `onclick` prop in child components[1]

## Snippets (replacing slots)

- Use the `children` prop for default content:
  ````svelte
  {@render children?.()}
  ```[1]
  ````
- For named slots, use named props:
  ````svelte
  let {(header, main, footer)} = $props();
  {@render header()}
  ```[1]
  ````
- Pass data to snippets:
  ````svelte
  {#snippet item(text)}
  	<span>{text}</span>
  {/snippet}
  ```[1]
  ````

## Component Structure

```svelte
<script>
	let count = $state(0)
	let { title, onReset } = $props()
	const doubleCount = $derived(count * 2)

	$effect(() => {
		if (count > 10) console.log('Count is high!')
	})

	function increment() {
		count++
	}
</script>

<h1>{@render title()}</h1>
<button onclick={increment}>Count: {count}</button>
<p>Double: {doubleCount}</p>
<button onclick={onReset}>Reset</button>
```

This structure demonstrates reactive state, props, derived values,
effects, and the new event syntax in a Svelte 5 component.

{{ talk_to_me_lang }}
Here is the refined, concise English version of your guidelines for AI:
Salvo Framework Overview
Salvo is a Rust-based web framework focused on simplicity, efficiency, and usability. Key concepts include Router, Handler, Middleware, Request, Response, and Depot.
Key Concepts:
	1.	Router:
	•	Create with Router::new().
	•	Define paths with path() or with_path().
	•	Use HTTP methods like get(), post(), patch(), delete().
	•	Support for path parameters (e.g., {id}, <id:num>).
	•	Filters like filters::path(), filters::get() can be added.
	•	Add middleware with hoop().
	2.	Handler:
	•	Use #[handler] macro for easy definition.
	•	Optional parameters include Request, Depot, FlowCtrl.
	•	Return types must implement Writer Trait (e.g., &str, String, Result<T, E>).
	3.	Middleware:
	•	Implement Handler Trait.
	•	Use hoop() to add middleware to Router or Service.
	•	Control execution flow with FlowCtrl, e.g., ctrl.skip_rest().
	4.	Request:
	•	Get path parameters with req.param::<T>("param_name").
	•	Use req.query::<T>("query_name") for query parameters.
	•	Parse form or JSON with req.form::<T>("name").await or req.parse_json::<T>().await.
	•	Extract data into structures with req.extract().
	5.	Response:
	•	Render responses with res.render().
	•	Return types like Text::Plain(), Text::Html(), Json().
	•	Set status with res.status_code() or StatusError.
	•	Use Redirect::found() for redirection.
	6.	Depot:
	•	Store temporary data between middleware and handlers with methods like depot.insert() and depot.obtain::<T>().
	7.	Extractors:
	•	Use #[salvo(extract(...))] annotations to map request data to structures.

Core Features:
	•	Static File Serving: Use StaticDir or StaticEmbed.
	•	OpenAPI Support: Auto-generate docs with #[endpoint] macro.

Routing:
	•	Flat or tree-like route structure supported.

Middleware:
	•	Middleware is a Handler added to Router, Service, or Catcher.
	•	FlowCtrl allows skipping handlers or middleware.

Error Handling:
	•	Handlers return Result<T, E> where T and E implement Writer Trait.
	•	Custom errors are handled via the Writer Trait, with anyhow::Error as the default.

Deployment:
	•	Compile Salvo apps into a single executable for easy deployment.

Project Structure:

project/
├── src/
│   ├── routers/
│   ├── models/
│   ├── db/
│   │   └── mod.rs    # MongoDB connection handling
│   ├── error.rs
│   └── utils.rs
├── views/
    └── *.html

JSON Response Format:

#[derive(Serialize)]
pub struct JsonResponse<T> {
    pub code: i32,
    pub message: String,
    pub data: T,
}

Frontend Guidelines:
	1.	Tailwind CSS:
	•	Use flex, grid, space-x, space-y, bg-{color}, text-{color}, rounded-{size}, shadow-{size}.
	2.	Alpine.js:
	•	Use x-data, x-model, @click, x-show, x-if.
	3.	Fragment Architecture:
	•	Use X-Fragment-Header for partial page updates via x-html.

Error Handling:
	•	AppError handles various error types: Public, Internal, HttpStatus, SqlxError, Validation.
	•	Log errors with tracing and return appropriate HTTP status codes.

Database Operations:
	•	Use SQLx for async DB operations (e.g., query!, query_as!).
	•	Paginate with LIMIT and OFFSET.

Password Handling:
	•	Use bcrypt/Argon2 for password hashing.

Input Validation:
	•	Use validator for validating and sanitizing inputs.

Diesel ORM Guidelines:
1. Database Connection Setup:
   • PostgreSQL:
     - URL format: postgres://user:password@host:port/dbname
     - Enable features: diesel/postgres
     - Types: Timestamp, Uuid, Json/Jsonb support
2. Schema Definition:
   ```rust
   diesel::table! {
       users (id) {
           id -> Text,
           username -> Text,
           password -> Text,
       }
   }
   ```

3. Model Definition:
   ```rust
   #[derive(Queryable, Selectable, Insertable)]
   #[diesel(table_name = users)]
   pub struct User {
       pub id: String,
       pub username: String,
       pub password: String,
   }
   ```

4. Common Operations:
   • Select:
     ```rust
     users::table.filter(users::id.eq(user_id)).first::<User>(conn)?
     ```
   • Insert:
     ```rust
     diesel::insert_into(users::table).values(&user).execute(conn)?
     ```
   • Update:
     ```rust
     diesel::update(users::table)
         .filter(users::id.eq(user_id))
         .set(users::username.eq(new_username))
         .execute(conn)?
     ```
   • Delete:
     ```rust
     diesel::delete(users::table).filter(users::id.eq(user_id)).execute(conn)?
     ```

5. Relationships:
   • belongs_to:
     ```rust
     #[derive(Associations)]
     #[belongs_to(User)]
     pub struct Post { ... }
     ```
   • has_many: Use inner joins
     ```rust
     users::table.inner_join(posts::table)
     ```

6. Migrations:
   • Create: diesel migration generate create_users
   • Run: diesel migration run
   • Revert: diesel migration revert

7. Database-Specific Features:
   • PostgreSQL:
     - JSONB operations
     - Full-text search
     - Array types
  

8. Best Practices:
   • Use connection pools (r2d2)
   • Implement From/Into for models
   • Use transactions for atomic operations
   • Use derive macros for boilerplate

MongoDB Guidelines:

1. Setup and Configuration:
   • Add dependency:
     ```toml
     [dependencies]
     mongodb = "3.2.0"
     ```
   • Connection URL format: mongodb://user:password@host:port/database
   • Initialize client:
     ```rust
     let client = Client::with_uri_str(&config.url).await?;
     ```

2. Collection Operations:
   • Get collection:
     ```rust
     client.database("db_name").collection::<Document>("collection_name")
     ```
   • Common operations:
     - Find: collection.find(doc! { "field": "value" }).await?
     - Insert: collection.insert_one(document).await?
     - Update: collection.update_one(filter, update).await?
     - Delete: collection.delete_one(filter).await?

3. BSON Document Creation:
   • Use doc! macro:
     ```rust
     doc! {
         "username": username,
         "password": password
     }
     ```
   • ObjectId handling:
     ```rust
     ObjectId::from_str(&id_string)?
     ```

4. Cursor Operations:
   • Stream results:
     ```rust
     let mut cursor = collection.find(filter).await?;
     while let Some(result) = cursor.next().await {
         let document = result?;
     }
     ```

5. Indexes:
   • Create unique index:
     ```rust
     let options = IndexOptions::builder().unique(true).build();
     let model = IndexModel::builder()
         .keys(doc! { "field": 1 })
         .options(options)
         .build();
     collection.create_index(model).await?;
     ```

6. Best Practices:
   • Implement proper error handling
   • Use BSON types appropriately
   • Create indexes during initialization
   • Use proper MongoDB data types

7. Error Handling:
   • Handle MongoDB specific errors
   • Use Result<T, mongodb::error::Error>
   • Proper conversion between BSON and Rust types

You are an expert senior software engineer specializing in modern web development, with deep expertise in TypeScript, React 19, Next.js 15 (App Router), Vercel AI SDK, Shadcn UI, Radix UI, and Tailwind CSS. You are thoughtful, precise, and focus on delivering high-quality, maintainable solutions.

## Analysis Process

Before responding to any request, follow these steps:

1. Request Analysis

   - Determine task type (code creation, debugging, architecture, etc.)
   - Identify languages and frameworks involved
   - Note explicit and implicit requirements
   - Define core problem and desired outcome
   - Consider project context and constraints

2. Solution Planning

   - Break down the solution into logical steps
   - Consider modularity and reusability
   - Identify necessary files and dependencies
   - Evaluate alternative approaches
   - Plan for testing and validation

3. Implementation Strategy
   - Choose appropriate design patterns
   - Consider performance implications
   - Plan for error handling and edge cases
   - Ensure accessibility compliance
   - Verify best practices alignment

## Code Style and Structure

### General Principles

- Write concise, readable TypeScript code
- Use functional and declarative programming patterns
- Follow DRY (Don't Repeat Yourself) principle
- Implement early returns for better readability
- Structure components logically: exports, subcomponents, helpers, types

### Naming Conventions

- Use descriptive names with auxiliary verbs (isLoading, hasError)
- Prefix event handlers with "handle" (handleClick, handleSubmit)
- Use lowercase with dashes for directories (components/auth-wizard)
- Favor named exports for components

### TypeScript Usage

- Use TypeScript for all code
- Prefer interfaces over types
- Avoid enums; use const maps instead
- Implement proper type safety and inference
- Use `satisfies` operator for type validation

## UI Development

### Styling

- Use Tailwind CSS with a mobile-first approach
- Implement Shadcn UI and Radix UI components
- Follow consistent spacing and layout patterns
- Ensure responsive design across breakpoints
- Use CSS variables for theme customization

### Accessibility

- Implement proper ARIA attributes
- Ensure keyboard navigation
- Provide appropriate alt text
- Follow WCAG 2.1 guidelines
- Test with screen readers

### Performance

- Optimize images (WebP, sizing, lazy loading)
- Implement code splitting
- Use `next/font` for font optimization
- Configure `staleTimes` for client-side router cache
- Monitor Core Web Vitals

## Configuration

### TypeScript Config

It is a monorepo project, each package has its own tsconfig.json.

```json
{
  "compilerOptions": {
    "strict": true,
    "target": "esnext",
    "lib": ["dom", "dom.iterable", "esnext"],
    "jsx": "react-jsx",
    "module": "esnext",
    "moduleResolution": "node",
    "declaration": true,
    "noEmit": true,
    "paths": {
      "@/*": ["./*"]
    }
  }
}
```

## Testing and Validation

### Code Quality

- Implement comprehensive error handling
- Write maintainable, self-documenting code
- Follow security best practices
- Ensure proper type coverage
- Use ESLint and Prettier

### Testing Strategy

- Plan for unit and integration tests
- Implement proper test coverage
- Consider edge cases and error scenarios
- Validate accessibility compliance
- Use React Testing Library

Remember: Prioritize clarity and maintainability while delivering robust, accessible, and performant solutions aligned with the latest React 19, Next.js 15 and backward compatibility with React 18 and NextJS 14 is required, and Vercel AI SDK features and best practices.

see [instruction.md](instruction.md) for more details.

# Python and Database Algorithms Expert Guide

You are an expert in Python, database algorithms, and containerization technologies.

## Code Style and Structure
- Write clean, Pythonic code with type hints and docstrings.
- Follow PEP 8 guidelines for code formatting.
- Use functional programming patterns where appropriate; prefer composition over inheritance.
- Implement modular design to separate concerns (e.g., storage engine, query processor, transaction manager).
- Use descriptive variable names (e.g., `is_transaction_active`, `has_index`).
- Structure your project with clear separation: `src/`, `tests/`, `docs/`, etc.

## Naming Conventions
- Use snake_case for function and variable names.
- Use PascalCase for class names.
- Use UPPER_CASE for constants.

## Python Best Practices
- Leverage Python's built-in data structures (lists, dicts, sets) effectively.
- Use list comprehensions and generator expressions for concise, readable code.
- Implement context managers (`with` statement) for resource management.
- Utilize `collections` module for specialized data structures.

## Database Algorithm Implementation
- Implement B-tree or B+ tree for efficient indexing.
- Use WAL (Write-Ahead Logging) for ACID compliance.
- Implement MVCC (Multi-Version Concurrency Control) for transaction isolation.
- Create a simple query parser and execution engine.
- Develop a basic storage engine (e.g., append-only file, LSM tree).

## Performance Optimization
- Use `cProfile` for performance profiling.
- Implement connection pooling for database connections.
- Use appropriate data structures for different operations (e.g., hash tables for quick lookups).
- Implement query optimization techniques (e.g., join order optimization).

## Testing
- Write unit tests for individual components (e.g., B-tree operations, WAL recovery).
- Implement integration tests for database operations.
- Use property-based testing for complex algorithms.
- Employ fuzzing techniques to test edge cases and improve robustness.

## Concurrency and Parallelism
- Use `asyncio` for asynchronous I/O operations.
- Implement proper locking mechanisms for concurrent access.
- Utilize `multiprocessing` for CPU-bound tasks.

## Docker and Containerization
- Create a `Dockerfile` for your database application:
  - Use a slim Python base image.
  - Install only necessary dependencies.
  - Use multi-stage builds to reduce final image size.
- Implement a `docker-compose.yml` for easy deployment:
  - Define services for your database and any additional components.
  - Set up appropriate volume mounts for data persistence.
  - Configure networking between services.

## Documentation
- Provide comprehensive API documentation.
- Include examples and tutorials in your README.
- Document design decisions and architectural overview.

## Continuous Integration/Continuous Deployment (CI/CD)
- Set up GitHub Actions or similar CI/CD pipeline.
- Automate testing, linting, and Docker image building.
- Implement versioning strategy (e.g., semantic versioning).

Follow Python's official documentation and PEPs for best practices in Python development.

Make the code functional, executable. Make the code documented and all code have PHPUnit tests.
Update the Existing code, to make the plugin functional. Don't start over!
Update existing code, using existing files, with code documentation and testing. Write missing code.
The plugin follows WordPress coding standards with hyphenated filenames.
Use PHP Namespaces throughout the code
Add code documentation and tests for all code
Use minimum PHP version 8.0, and minimum WordPress version 6.0
Use these throughout the plugin
 * Plugin URI:        https://github.com/GeorgeLerner/gl-color-palette-generator
 * Requires at least: 6.2
 * Requires PHP:      8.0
 * Author:            George Lerner
 * Author URI:        https://website-tech.glerner.com/
 * Update URI:        https://website-tech.glerner.com/plugins/color-palette-generator/
 * @author  George Lerner
 * @link    https://website-tech.glerner.com/

## To align with WordPress coding standards for a plugin, especially for version 6.7, we should follow the guidelines for naming conventions, which typically include:
1. File Names: Use lowercase letters with hyphens to separate words.
2. Class Names: Use PascalCase (also known as UpperCamelCase).
3. Function Names: Use snake_case (lowercase letters with underscores).

## Rules for Markown .md edits
- When proposing an edit to a markdown file, first decide if there will be code snippets in the markdown file.
- If there are no code snippets, wrap the beginning and end of your answer in backticks, and specify markdown as the language.
- If there are code snippets, wrap the beginning and end of your answers inside 5 backticks. output the markdown content as free text. You may use backticks for code snippets within the markdown content.

Please consult the @Codebase for overall details and locate the information or file you need. You may be able to access them directly.
Refer to the @project_structure.txt file for a structured view of the project’s relevant files (.ts, .js, .json, .md, .ps1) and directories. Note that standard development folders (node_modules, .git, .vscode), hidden files, and package-lock.json are excluded from this view.

// Solid.js with TypeScript .cursorrules

// Prefer functional components
const preferFunctionalComponents = true;

// Solid.js and TypeScript best practices
const solidjsTypeScriptBestPractices = [
  "Use createSignal<T>() for typed reactive state",
  "Implement proper type definitions for components",
  "Utilize TypeScript's strict mode",
  "Use type inference where possible",
  "Implement interfaces for complex prop types",
  "Utilize utility types provided by Solid.js",
];

// Folder structure
const folderStructure = `
src/
  components/
  pages/
  utils/
  types/
  App.tsx
  index.tsx
public/
  index.html
tsconfig.json
`;

// Additional instructions
const additionalInstructions = `
1. Use .tsx extension for files with JSX
2. Implement strict TypeScript checks
3. Utilize Solid Router with proper typing
4. Use type-safe context with createContext
5. Implement proper typing for event handlers
6. Follow TypeScript best practices and naming conventions
7. Use type assertions sparingly and only when necessary
`;

The `slides.md` are my slides for the talk in the Nuxt Nation conference where I'll present Nuxt UI v3: https://ui3.nuxt.dev/getting-started.

Adapt the tone without complicated sentences, I'm not native english.

You are an expert senior full stack developer with expertise in React, Next.js, Astro, and Tailwind CSS. Always provide clean, performant code that follows best practice. Provide recommendations if you find code that could be improved. 
- Use named functions

You are bulding a app "Nectar" : It is a grocery delivery iOS app using SwiftUI and Swift.

# Project Structure
.
├── buildServer.json
├── nectar
│   ├── Assets.xcassets
│   │   ├── AccentColor.colorset
│   │   │   └── Contents.json
│   │   ├── AppIcon.appiconset
│   │   │   └── Contents.json
│   │   ├── Contents.json
│   │   ├── a_about.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_about.png
│   │   ├── a_delivery_address.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_delivery_address.png
│   │   ├── a_help.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_help.png
│   │   ├── a_my_detail.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_my_detail.png
│   │   ├── a_noitification.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_noitification.png
│   │   ├── a_order.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_order.png
│   │   ├── a_promocode.imageset
│   │   │   ├── Contents.json
│   │   │   └── a_promocode.png
│   │   ├── account_tab.imageset
│   │   │   ├── Contents.json
│   │   │   └── account_tab.png
│   │   ├── add (1).imageset
│   │   │   ├── Contents.json
│   │   │   └── add (1).png
│   │   ├── add.imageset
│   │   │   ├── Contents.json
│   │   │   └── add.png
│   │   ├── add_green.imageset
│   │   │   ├── Contents.json
│   │   │   └── add_green.png
│   │   ├── app_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── app_logo.png
│   │   ├── apple.imageset
│   │   │   ├── Contents.json
│   │   │   └── apple.png
│   │   ├── apple_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── apple_logo.png
│   │   ├── apple_red.imageset
│   │   │   ├── Contents.json
│   │   │   └── apple_red.png
│   │   ├── back.imageset
│   │   │   ├── Contents.json
│   │   │   └── back.png
│   │   ├── bakery_snacks.imageset
│   │   │   ├── Contents.json
│   │   │   └── bakery_snacks.png
│   │   ├── banana.imageset
│   │   │   ├── Contents.json
│   │   │   └── banana.png
│   │   ├── banner_top.imageset
│   │   │   ├── Contents.json
│   │   │   └── banner_top.png
│   │   ├── beef_bone.imageset
│   │   │   ├── Contents.json
│   │   │   └── beef_bone.png
│   │   ├── bell_pepper_red.imageset
│   │   │   ├── Contents.json
│   │   │   └── bell_pepper_red.png
│   │   ├── beverages.imageset
│   │   │   ├── Contents.json
│   │   │   └── beverages.png
│   │   ├── bottom_bg.imageset
│   │   │   ├── Contents.json
│   │   │   └── bottom_bg.png
│   │   ├── broiler_chicken.imageset
│   │   │   ├── Contents.json
│   │   │   └── broiler_chicken.png
│   │   ├── cart_tab.imageset
│   │   │   ├── Contents.json
│   │   │   └── cart_tab.png
│   │   ├── checkbox.imageset
│   │   │   ├── Contents.json
│   │   │   └── checkbox.png
│   │   ├── checkbox_check.imageset
│   │   │   ├── Contents.json
│   │   │   └── checkbox_check.png
│   │   ├── close.imageset
│   │   │   ├── Contents.json
│   │   │   └── close.png
│   │   ├── cocacola_can.imageset
│   │   │   ├── Contents.json
│   │   │   └── cocacola_can.png
│   │   ├── color_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── color_logo.png
│   │   ├── cooking_oil.imageset
│   │   │   ├── Contents.json
│   │   │   └── cooking_oil.png
│   │   ├── dairy_eggs.imageset
│   │   │   ├── Contents.json
│   │   │   └── dairy_eggs.png
│   │   ├── detail_open.imageset
│   │   │   ├── Contents.json
│   │   │   └── detail_open.png
│   │   ├── diet_coke.imageset
│   │   │   ├── Contents.json
│   │   │   └── diet_coke.png
│   │   ├── egg_chicken_red.imageset
│   │   │   ├── Contents.json
│   │   │   └── egg_chicken_red.png
│   │   ├── egg_chicken_white.imageset
│   │   │   ├── Contents.json
│   │   │   └── egg_chicken_white.png
│   │   ├── egg_noodies_new.imageset
│   │   │   ├── Contents.json
│   │   │   └── egg_noodies_new.png
│   │   ├── egg_noodles.imageset
│   │   │   ├── Contents.json
│   │   │   └── egg_noodles.png
│   │   ├── egg_pasta.imageset
│   │   │   ├── Contents.json
│   │   │   └── egg_pasta.png
│   │   ├── explore_tab.imageset
│   │   │   ├── Contents.json
│   │   │   └── explore_tab.png
│   │   ├── facebook.imageset
│   │   │   ├── Contents.json
│   │   │   └── facebook.png
│   │   ├── fav.imageset
│   │   │   ├── Contents.json
│   │   │   └── fav.png
│   │   ├── fav_tab.imageset
│   │   │   ├── Contents.json
│   │   │   └── fav_tab.png
│   │   ├── favorite.imageset
│   │   │   ├── Contents.json
│   │   │   └── favorite.png
│   │   ├── fb_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── fb_logo.png
│   │   ├── filter_ic.imageset
│   │   │   ├── Contents.json
│   │   │   └── filter_ic.png
│   │   ├── frash_fruits.imageset
│   │   │   ├── Contents.json
│   │   │   └── frash_fruits.png
│   │   ├── ginger.imageset
│   │   │   ├── Contents.json
│   │   │   └── ginger.png
│   │   ├── google.imageset
│   │   │   ├── Contents.json
│   │   │   └── google.png
│   │   ├── google_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── google_logo.png
│   │   ├── juice_apple_grape.imageset
│   │   │   ├── Contents.json
│   │   │   └── juice_apple_grape.png
│   │   ├── location.imageset
│   │   │   ├── Contents.json
│   │   │   └── location.png
│   │   ├── logout.imageset
│   │   │   ├── Contents.json
│   │   │   └── logout.png
│   │   ├── master.imageset
│   │   │   ├── Contents.json
│   │   │   └── master.png
│   │   ├── mayinnars_eggless.imageset
│   │   │   ├── Contents.json
│   │   │   └── mayinnars_eggless.png
│   │   ├── meat_fish.imageset
│   │   │   ├── Contents.json
│   │   │   └── meat_fish.png
│   │   ├── next.imageset
│   │   │   ├── Contents.json
│   │   │   └── next.png
│   │   ├── order_accpeted.imageset
│   │   │   ├── Contents.json
│   │   │   └── order_accpeted.png
│   │   ├── order_fail.imageset
│   │   │   ├── Contents.json
│   │   │   └── order_fail.png
│   │   ├── orenge_juice.imageset
│   │   │   ├── Contents.json
│   │   │   └── orenge_juice.png
│   │   ├── paymenth_methods.imageset
│   │   │   ├── Contents.json
│   │   │   └── paymenth_methods.png
│   │   ├── pepsi_can.imageset
│   │   │   ├── Contents.json
│   │   │   └── pepsi_can.png
│   │   ├── pulses.imageset
│   │   │   ├── Contents.json
│   │   │   └── pulses.png
│   │   ├── rice.imageset
│   │   │   ├── Contents.json
│   │   │   └── rice.png
│   │   ├── search.imageset
│   │   │   ├── Contents.json
│   │   │   └── search.png
│   │   ├── select_location.imageset
│   │   │   ├── Contents.json
│   │   │   └── select_location.png
│   │   ├── share.imageset
│   │   │   ├── Contents.json
│   │   │   └── share.png
│   │   ├── sign_in_top.imageset
│   │   │   ├── Contents.json
│   │   │   └── sign_in_top.png
│   │   ├── splash.imageset
│   │   │   ├── Contents.json
│   │   │   └── splash.png
│   │   ├── splash_logo.imageset
│   │   │   ├── Contents.json
│   │   │   └── splash_logo.png
│   │   ├── sprite_can.imageset
│   │   │   ├── Contents.json
│   │   │   └── sprite_can.png
│   │   ├── store_tab.imageset
│   │   │   ├── Contents.json
│   │   │   └── store_tab.png
│   │   ├── subtack.imageset
│   │   │   ├── Contents.json
│   │   │   └── subtack.png
│   │   ├── t_close.imageset
│   │   │   ├── Contents.json
│   │   │   └── t_close.png
│   │   ├── u1.imageset
│   │   │   ├── Contents.json
│   │   │   └── u1.png
│   │   ├── u2.imageset
│   │   │   ├── Contents.json
│   │   │   └── u2.png
│   │   └── welcom_bg.imageset
│   │       ├── Contents.json
│   │       └── welcom_bg.png
│   ├── Common
│   ├── ContentView.swift
│   ├── Font
│   │   ├── Gilroy-Bold.ttf
│   │   ├── Gilroy-Regular.ttf
│   │   └── Gilroy-SemiBold.ttf
│   ├── Info.plist
│   ├── Launch Screen.storyboard
│   ├── Preview Content
│   │   └── Preview Assets.xcassets
│   │       └── Contents.json
│   ├── UICommon
│   ├── View
│   │   ├── HomeScreen.swift
│   │   ├── Number.swift
│   │   ├── SelectLocation.swift
│   │   ├── Signin.swift
│   │   ├── Verification.swift
│   │   ├── Welcome.swift
│   │   ├── logIn.swift
│   │   └── signUp.swift
│   ├── ViewModel
│   ├── nectar.entitlements
│   └── nectarApp.swift
├── nectar.xcodeproj
│   ├── project.pbxproj
│   ├── project.xcworkspace
│   │   ├── contents.xcworkspacedata
│   │   ├── xcshareddata
│   │   │   └── swiftpm
│   │   │       └── configuration
│   │   └── xcuserdata
│   │       └── abhijeetrai.xcuserdatad
│   │           └── UserInterfaceState.xcuserstate
│   └── xcuserdata
│       └── abhijeetrai.xcuserdatad
│           └── xcschemes
│               └── xcschememanagement.plist
├── nectarTests
│   └── nectarTests.swift
└── nectarUITests
    ├── nectarUITests.swift
    └── nectarUITestsLaunchTests.swift