Axios is a promise-based HTTP client for the browser and Node.js. It provides a simple, elegant API for making HTTP requests with features like interceptors, request/response transformation, automatic JSON data handling, and request cancellation.

- **ES6 Modules**: The library uses ES6 import/export syntax throughout

- **Platform Abstraction**: Code is organized to support both browser and Node.js environments via the `platform/` directory

- **Adapter Pattern**: HTTP requests are handled through adapters (XHR, HTTP, Fetch) selected based on the environment

- **Axios**: Main class that manages request dispatching and interceptor chains

- **AxiosError**: Custom error class with standardized error codes (ERR_NETWORK, ETIMEDOUT, etc.)

- **AxiosHeaders**: Manages HTTP headers with case-insensitive access and normalization

- **InterceptorManager**: Handles request/response interceptors with synchronous/asynchronous support

- **xhr.js**: XMLHttpRequest adapter for browsers

- **http.js**: Node.js HTTP/HTTPS adapter

- **fetch.js**: Fetch API adapter

- Adapters are selected automatically based on environment capabilities

- Comprehensive type checking functions (isArray, isObject, isString, etc.)

- Object manipulation utilities (merge, extend, forEach)

- Platform-agnostic helper functions

- Uses functional programming patterns with pure functions

- URL building and parameter serialization

- Form data handling and conversion

- Progress event management

- Request/response transformation utilities

1. **Strict Mode**: Always use `'use strict';` at the top of files

2. **Function Documentation**: Use JSDoc comments for all public functions with @param and @returns tags

3. **Import Style**: Use named imports from relative paths with `.js` extension

4. **Error Handling**: Always use AxiosError with appropriate error codes

5. **Null Checks**: Use explicit checks (`=== null`, `!== undefined`) rather than truthy/falsy checks where precision matters

- **Classes**: PascalCase (e.g., `Axios`, `AxiosError`, `InterceptorManager`)

- **Functions**: camelCase (e.g., `buildURL`, `mergeConfig`, `dispatchRequest`)

- **Constants**: UPPER_SNAKE_CASE for error codes (e.g., `ERR_NETWORK`, `ETIMEDOUT`)

- **Private symbols**: Use Symbol for internal properties (e.g., `$internals`)

- **Helper functions**: Prefix with underscore for internal helpers (e.g., `_request`)

throw new AxiosError(message, code, config, request, response);

AxiosError.ERR_BAD_REQUEST;

AxiosError.ERR_NETWORK;

AxiosError.ETIMEDOUT;

AxiosError.ECONNABORTED;

AxiosError.ERR_CANCELED;

- Use `mergeConfig()` to combine configuration objects

- Support both function and object forms for serializers

- Validate options using the `validator` helper

- Apply defaults from `lib/defaults/index.js`

interceptors.request.use(onFulfilled, onRejected, {

synchronous: false,

runWhen: (config) => config.custom === true,

});

- Adapters are tried in order: ['xhr', 'http', 'fetch']

- Use capability detection, not environment detection

- Each adapter returns a Promise

transformRequest: [function(data, headers) {

// Transform request data

return data;

}],

transformResponse: [function(data) {

// Transform response data

return data;

}]

- Deep merge for nested objects

- Header normalization and flattening

- Method-specific headers override common headers

- **Browser**: Uses XHR or Fetch adapter, includes XSRF protection

- **Node.js**: Uses HTTP/HTTPS adapter, supports streams

- Platform-specific classes in `lib/platform/browser/` and `lib/platform/node/`

const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";

- Functions should be pure and testable in isolation

- Use dependency injection for platform-specific features

- Mock adapters for unit tests

- Support for cancellation should be tested thoroughly

1. **Don't** use global variables or singletons

2. **Don't** assume browser or Node.js specific APIs are available

3. **Don't** mutate configuration objects - always return new objects

4. **Don't** throw generic Error objects - use AxiosError

5. **Don't** use `.bind()` without the helper function from `lib/helpers/bind.js`

6. **Don't** add new dependencies without discussion

- The library includes TypeScript definitions (index.d.ts)

- Maintain compatibility with existing type definitions

- Use utils type checking functions consistently (utils.isArray, utils.isString, etc.)

- Minimize object allocations in hot paths

- Reuse headers objects when possible

- Use efficient string operations

- Avoid unnecessary array iterations

- Cache compiled regular expressions

1. **Request Creation**: User calls `axios()` or `axios.get/post()` etc.

2. **Config Merging**: Merge instance defaults with request config

3. **Request Interceptors**: Execute in reverse order of registration

4. **Adapter Selection**: Choose appropriate adapter for environment

5. **Request Transformation**: Apply transformRequest functions

6. **HTTP Request**: Adapter performs actual HTTP request

7. **Response Transformation**: Apply transformResponse functions

8. **Response Interceptors**: Execute in order of registration

9. **Promise Resolution**: Return response or throw error

- Support both CancelToken (legacy) and AbortSignal (modern)

- Always cleanup listeners to prevent memory leaks

- Cancel should work at any stage of the request

import buildURL from "./helpers/buildURL.js";

const url = buildURL(baseURL, params, paramsSerializer);

import AxiosHeaders from "./core/AxiosHeaders.js";

const headers = AxiosHeaders.from(rawHeaders).normalize();

import utils from "./utils.js";

if (utils.isObject(data) && !utils.isStream(data)) {

// Handle object data

}

1. Consider both browser and Node.js environments

2. Add appropriate error codes if needed

3. Update TypeScript definitions

4. Maintain backward compatibility

5. Add JSDoc documentation

6. Consider performance implications

7. Test with interceptors and transformations

8. Validate configuration options properly

When suggesting code:

1. **Compatibility First**: Maintain backward compatibility

2. **Platform Agnostic**: Work in both browser and Node.js

3. **Error Handling**: Use AxiosError consistently

4. **Documentation**: Include JSDoc comments

5. **Performance**: Avoid unnecessary operations

6. **Type Safety**: Use utils type checking consistently

"use strict";

import utils from "../utils.js";

export default function helperName(paramName) {

// Validate inputs

if (!utils.isString(paramName)) {

throw new TypeError("paramName must be a string");

}

// Implementation

return result;

}

"use strict";

import utils from "../utils.js";

class ClassName {

constructor(config) {

this.config = config || {};

}

/**

methodName(param) {

// Implementation

}

}

export default ClassName;

import AxiosError from "../core/AxiosError.js";

throw new AxiosError(

"Descriptive error message",

AxiosError.ERR_APPROPRIATE_CODE,

config,

request,

response

);

const axiosError = AxiosError.from(error, code, config, request, response);

When working with Axios code, prioritize compatibility, use the established patterns for error handling and configuration, leverage the utils library for type checking, and ensure code works across both browser and Node.js environments. Always document your code with JSDoc and maintain the functional programming style used throughout the library.