@plyaz/api 1.0.0

package/README.md

@@ -0,0 +1,693 @@
+# @plyaz/api
+
+Unified API client for seamless backend communication across the Plyaz platform. Provides type-safe endpoints, React Query integration, consistent error handling, and intelligent request management - supporting Web3, authentication, and tokenized experiences.
+
+## Overview
+
+The @plyaz/api package provides a unified API client for communicating with backend services across the Plyaz platform. It offers type-safe API endpoints, consistent error handling, and integration with React Query for efficient data fetching. This package serves as the core communication layer between frontend applications and backend services.
+
+> **Note**: This package is designed as a shared package that works across frontend and backend contexts, with platform-specific implementations where necessary. It integrates seamlessly with the @plyaz/* ecosystem of shared packages.
+
+## Features
+
+- **Type-Safe API Client**: Built on `fetchff` with full TypeScript support
+- **React Query Integration**: Ready-to-use hooks for data fetching and mutations
+- **Consistent Error Handling**: Integrated with `@plyaz/errors` for standardized errors
+- **Request Management**: Deduplication, cancellation, and retry mechanisms
+- **Authentication Support**: Built-in auth token handling and interceptors
+- **Pagination Support**: Cursor and offset-based pagination utilities
+- **Performance Optimized**: Request batching, caching, and queue management
+- **Event Integration**: Lifecycle events via `@plyaz/events`
+- **Third-Party APIs**: Support for Alchemy, The Graph, and other integrations
+
+## Installation
+
+```bash
+pnpm add @plyaz/api
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js >= 22.4.0
+- pnpm >= 8.0.0
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/Plyaz-Official/api.git
+cd api
+
+# Install dependencies
+pnpm install
+
+# Start development (watch mode)
+pnpm dev
+```
+
+### Available Scripts
+
+```bash
+# Development
+pnpm dev                # Start development with watch mode (alias: pnpm build:watch)
+pnpm build:watch        # Watch files and rebuild on changes
+
+# Building
+pnpm build              # Full build (clean + JS + TypeScript declarations)
+pnpm build:js           # Build JavaScript bundles with tsup
+pnpm build:types        # Generate TypeScript declaration files
+pnpm clean              # Remove dist directory
+
+# Testing
+pnpm test               # Run all tests once
+pnpm test:watch         # Run tests in watch mode
+pnpm test:coverage      # Run tests with coverage report
+pnpm test:ui            # Open Vitest UI for interactive testing
+pnpm test:ci            # Run tests in CI environment
+
+# Code Quality
+pnpm lint               # Check code with ESLint
+pnpm lint:fix           # Auto-fix ESLint issues
+pnpm format             # Format code with Prettier
+pnpm format:check       # Check if code is formatted correctly
+pnpm type:check         # Type check with TypeScript (no emit)
+
+# Security & Auditing
+pnpm audit              # Basic security audit
+pnpm audit:moderate     # Check for moderate+ vulnerabilities
+pnpm audit:high         # Check for high+ vulnerabilities
+pnpm audit:critical     # Check only critical vulnerabilities
+pnpm audit:fix          # Auto-fix vulnerabilities where possible
+pnpm audit:enhanced     # Enhanced audit with audit-ci
+pnpm security:check     # Full security check (moderate + audit-ci)
+
+# Publishing
+pnpm prepublishOnly     # Runs build, test, and lint before publishing
+```
+
+## Package Structure
+
+```
+@plyaz/api/
+├── src/
+│   ├── client/                 # API client implementation
+│   │   ├── createApiClient.ts  # Factory function for API client
+│   │   ├── defaultConfig.ts    # Default configuration
+│   │   └── types.ts            # Client-specific types
+│   ├── endpoints/              # API endpoint definitions
+│   │   ├── auth.ts             # Authentication endpoints
+│   │   ├── user.ts             # User endpoints
+│   │   ├── nft.ts              # NFT endpoints
+│   │   └── transaction.ts      # Transaction endpoints
+│   ├── services/               # API service functions
+│   │   ├── auth.ts             # Auth service functions
+│   │   ├── user.ts             # User service functions
+│   │   └── nft.ts              # NFT service functions
+│   ├── integrations/           # Third-party API integrations
+│   │   └── alchemy/            # Alchemy API integration
+│   ├── hooks/                  # React Query hooks
+│   │   ├── auth/               # Auth-related hooks
+│   │   └── user/               # User-related hooks
+│   ├── utils/                  # Utility functions
+│   │   ├── error-handler.ts    # Error handling utilities
+│   │   └── pagination.ts       # Pagination utilities
+│   └── index.ts                # Main exports
+```
+
+## Quick Start
+
+### Basic Setup
+
+#### Initialize API Client
+
+```typescript
+import { createApiClient } from '@plyaz/api';
+
+// Create API client with custom configuration
+const api = createApiClient({
+  baseURL: process.env.NEXT_PUBLIC_API_URL,
+  timeout: 30000,
+  headers: {
+    'Content-Type': 'application/json'
+  }
+});
+
+// Or use the default pre-configured client
+import { api } from '@plyaz/api';
+```
+
+#### With Authentication
+
+```typescript
+import { createApiClient } from '@plyaz/api';
+
+const api = createApiClient({
+  onRequest: (config) => {
+    const token = localStorage.getItem('auth_token');
+    if (token) {
+      config.headers = {
+        ...config.headers,
+        Authorization: `Bearer ${token}`
+      };
+    }
+    return config;
+  }
+});
+```
+
+### React/Next.js Integration
+
+#### Query Hook Usage
+
+```typescript
+import { useGetUserProfile } from '@plyaz/api/hooks';
+
+export function UserProfile({ walletAddress }: { walletAddress: string }) {
+  const { data, error, isLoading } = useGetUserProfile(
+    { walletAddress },
+    { includeDetails: true }
+  );
+
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error.message}</div>;
+
+  return (
+    <div>
+      <h1>{data.username}</h1>
+      <p>{data.email}</p>
+    </div>
+  );
+}
+```
+
+#### Mutation Hook Usage
+
+```typescript
+import { useUpdateUserProfile } from '@plyaz/api/hooks';
+
+export function ProfileEditForm({ userId }: { userId: string }) {
+  const { mutate, isLoading } = useUpdateUserProfile();
+
+  const handleSubmit = (formData: UpdateUserRequest) => {
+    mutate(
+      { 
+        pathParams: { userId }, 
+        body: formData 
+      },
+      {
+        onSuccess: (data) => {
+          console.log('Profile updated:', data);
+        },
+        onError: (error) => {
+          console.error('Update failed:', error);
+        }
+      }
+    );
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      {/* Form fields */}
+      <button type="submit" disabled={isLoading}>
+        {isLoading ? 'Updating...' : 'Update Profile'}
+      </button>
+    </form>
+  );
+}
+```
+
+#### Infinite Query for Pagination
+
+```typescript
+import { useInfiniteTransactions } from '@plyaz/api/hooks';
+
+export function TransactionList({ walletAddress, chainId }: Props) {
+  const {
+    data,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage
+  } = useInfiniteTransactions(
+    { walletAddress, chainId },
+    { limit: 10 }
+  );
+
+  return (
+    <div>
+      {data?.pages.flatMap(page => 
+        page.transactions.map(tx => (
+          <div key={tx.id}>{tx.hash}</div>
+        ))
+      )}
+      
+      {hasNextPage && (
+        <button onClick={() => fetchNextPage()}>
+          {isFetchingNextPage ? 'Loading...' : 'Load More'}
+        </button>
+      )}
+    </div>
+  );
+}
+```
+
+### Service Functions
+
+```typescript
+import { getUserProfile, updateUserProfile } from '@plyaz/api/services';
+
+// Fetch user profile
+const profile = await getUserProfile(
+  { walletAddress: '0x123...' },
+  { includeDetails: true }
+);
+
+// Update user profile
+const updated = await updateUserProfile(
+  { userId: 'usr-123' },
+  { username: 'newusername', email: 'new@email.com' }
+);
+```
+
+## API Methods
+
+### GET Requests
+
+```typescript
+// Path parameters
+const { data } = await api.getUserProfile({
+  urlPathParams: { walletAddress: '0x123...' }
+});
+
+// Query parameters
+const { data } = await api.getUsers({
+  params: { page: 1, limit: 10 }
+});
+
+// Both path and query parameters
+const { data } = await api.getNFTs({
+  urlPathParams: { walletAddress: '0x123...', chainId: 'ethereum' },
+  params: { tokenType: 'ERC721' }
+});
+```
+
+### POST Requests
+
+```typescript
+// Simple POST
+const { data } = await api.createUser({
+  body: { username: 'johndoe', email: 'john@example.com' }
+});
+
+// POST with path parameters
+const { data } = await api.transferNFT({
+  urlPathParams: { walletAddress: '0x456...' },
+  body: { nftId: '123', toAddress: '0x789...' }
+});
+```
+
+### PUT/PATCH Requests
+
+```typescript
+// PUT request
+const { data } = await api.updateUserProfile({
+  urlPathParams: { userId: '123' },
+  body: { username: 'newusername' }
+});
+
+// PATCH request
+const { data } = await api.patchUserSettings({
+  urlPathParams: { userId: '123' },
+  body: { theme: 'dark' }
+});
+```
+
+### DELETE Requests
+
+```typescript
+// DELETE with path parameters
+const { data } = await api.deleteUser({
+  urlPathParams: { userId: '123' }
+});
+```
+
+## Configuration
+
+### Full Configuration Options
+
+```typescript
+{
+  // Base configuration
+  baseURL: process.env.NEXT_PUBLIC_API_URL,
+  timeout: 30000,
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  
+  // Request management
+  withCredentials: true,
+  cancellable: true,
+  dedupeTime: 1000,
+  
+  // Retry configuration
+  retry: {
+    retries: 3,
+    delay: 1000,
+    backoff: 1.5,
+    maxDelay: 10000,
+    retryOn: [408, 429, 500, 502, 503, 504]
+  },
+  
+  // Error handling strategy
+  strategy: 'softFail', // 'reject' | 'softFail' | 'defaultResponse' | 'silent'
+  
+  // Caching
+  cache: {
+    cacheTime: 60,
+    skipCache: (response, config) => config.method !== 'GET'
+  },
+  
+  // Interceptors
+  onRequest: (config) => config,
+  onResponse: (response) => response,
+  onError: (error) => error
+}
+```
+
+## Advanced Features
+
+### Request Cancellation
+
+```typescript
+// Enable automatic cancellation
+const { data } = await api.searchUsers({
+  params: { query: searchTerm },
+  cancellable: true,
+  rejectCancelled: true
+});
+```
+
+### Request Deduplication
+
+```typescript
+// Deduplicate identical requests within time window
+const { data } = await api.getUserProfile({
+  urlPathParams: { walletAddress: '0x123...' },
+  dedupeTime: 5000 // 5 seconds
+});
+```
+
+### Error Handling Strategies
+
+```typescript
+// Reject strategy (throws errors)
+try {
+  const { data } = await api.getUserProfile({
+    urlPathParams: { walletAddress: '0x123...' },
+    strategy: 'reject'
+  });
+} catch (error) {
+  console.error(error);
+}
+
+// SoftFail strategy (returns error property)
+const { data, error } = await api.getUserProfile({
+  urlPathParams: { walletAddress: '0x123...' },
+  strategy: 'softFail'
+});
+
+if (error) {
+  console.error(error);
+} else {
+  console.log(data);
+}
+
+// Silent strategy (fire-and-forget)
+api.trackUserActivity({
+  body: { action: 'page_view' },
+  strategy: 'silent'
+});
+```
+
+### Custom Interceptors
+
+```typescript
+const apiWithAuth = createApiClient({
+  onRequest: [
+    // Add authentication
+    (config) => {
+      const token = getAuthToken();
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`;
+      }
+      return config;
+    },
+    // Add tenant ID
+    (config) => {
+      config.headers['X-Tenant-ID'] = getTenantId();
+      return config;
+    }
+  ],
+  
+  onError: (error) => {
+    if (error.status === 401) {
+      router.push('/login');
+    }
+    return error;
+  }
+});
+```
+
+## Error Handling
+
+### With @plyaz/errors Integration
+
+```typescript
+import { isNotFoundError, isValidationError } from '@plyaz/errors';
+import { handleApiError } from '@plyaz/api/utils';
+
+const fetchUser = async (walletAddress: string) => {
+  const { data, error } = await api.getUserProfile({
+    urlPathParams: { walletAddress },
+    strategy: 'softFail'
+  });
+  
+  if (error) {
+    if (isNotFoundError(error)) {
+      console.log('User not found');
+    } else if (isValidationError(error)) {
+      console.log('Invalid parameters');
+    } else {
+      const handled = handleApiError(error);
+      console.error(handled.message);
+    }
+    return null;
+  }
+  
+  return data;
+};
+```
+
+## Pagination Utilities
+
+```typescript
+import { 
+  getCursorPaginationParams,
+  getOffsetPaginationParams,
+  getPaginationInfo 
+} from '@plyaz/api/utils';
+
+// Cursor-based pagination
+const cursorParams = getCursorPaginationParams('next_cursor_123', 10);
+
+// Offset-based pagination
+const offsetParams = getOffsetPaginationParams(2, 10); // Page 2, 10 items
+
+// Extract pagination info
+const { data } = await api.getUsers({ params: offsetParams });
+const info = getPaginationInfo(data);
+console.log(`Page ${info.currentPage} of ${info.totalPages}`);
+```
+
+## Third-Party Integrations
+
+### Alchemy API Integration
+
+```typescript
+import { AlchemyService } from '@plyaz/api/integrations/alchemy';
+
+const alchemy = new AlchemyService({
+  apiKey: process.env.ALCHEMY_API_KEY,
+  network: 'eth-mainnet'
+});
+
+// Get NFTs for wallet
+const nfts = await alchemy.getNFTs({
+  owner: '0x123...',
+  withMetadata: true
+});
+
+// Get token balances
+const balances = await alchemy.getTokenBalances({
+  address: '0x123...'
+});
+```
+
+## Platform Architecture Context
+
+The API client is a critical component of the Plyaz platform's shared package ecosystem:
+
+### Frontend Architecture
+- **Multiple Apps**: Supports web app, admin panel, and micro apps
+- **React Query**: Deep integration for efficient data fetching
+- **State Management**: Works with Zustand stores for state synchronization
+- **Next.js**: Optimized for server-side rendering and API routes
+
+### Backend Architecture
+- **Microservices**: Communicates with distributed NestJS services
+- **API Gateway**: Routes through centralized gateway with auth
+- **Event-Driven**: Supports async communication patterns
+- **GraphQL/REST**: Flexible endpoint configuration
+
+## Integration with Other Plyaz Packages
+
+| Package | Integration | Purpose |
+|---------|------------|---------|
+| **@plyaz/types** | Type definitions | Provides API interfaces and types |
+| **@plyaz/errors** | Error handling | Standardized error types and handlers |
+| **@plyaz/config** | Configuration | API URLs and environment settings |
+| **@plyaz/auth** | Authentication | Token management and auth headers |
+| **@plyaz/events** | Event bus | API lifecycle events |
+| **@plyaz/logger** | Logging | Request/response logging |
+| **@plyaz/web3** | Blockchain | Web3 transaction APIs |
+| **@plyaz/monitoring** | Metrics | API performance tracking |
+
+## Type Safety
+
+### Endpoint Type Definitions
+
+```typescript
+// Types are imported from @plyaz/types
+import type { 
+  UserMethods, 
+  TransactionMethods,
+  NFTMethods 
+} from '@plyaz/types/api';
+
+// Combined interface for all endpoints
+export interface EndpointsMethods extends 
+  UserMethods,
+  TransactionMethods,
+  NFTMethods {}
+```
+
+### Request/Response Types
+
+```typescript
+import type { 
+  ApiResponse,
+  PaginatedResponse,
+  ApiError 
+} from '@plyaz/types/api';
+
+// Type-safe responses
+type UserResponse = ApiResponse<User>;
+type UsersListResponse = PaginatedResponse<User>;
+```
+
+## Best Practices
+
+### Service Layer Pattern
+
+```typescript
+// services/user.ts
+export async function getUserProfile(
+  urlPathParams: GetUserProfilePathParams,
+  queryParams?: GetUserProfileQueryParams
+): Promise<UserProfile> {
+  return api.getUserProfile({
+    urlPathParams,
+    params: queryParams
+  });
+}
+```
+
+### Query Key Management
+
+```typescript
+// hooks/user/keys.ts
+export const userKeys = {
+  all: ['user'] as const,
+  lists: () => [...userKeys.all, 'list'] as const,
+  list: (params: any) => [...userKeys.lists(), params] as const,
+  profile: (id: string) => [...userKeys.all, 'profile', id] as const
+};
+```
+
+### Error Boundary Integration
+
+```typescript
+import { ErrorBoundary } from '@plyaz/ui';
+import { handleApiError } from '@plyaz/api/utils';
+
+function MyApp() {
+  return (
+    <ErrorBoundary
+      fallback={<ErrorFallback />}
+      onError={(error) => {
+        const handled = handleApiError(error);
+        logError(handled);
+      }}
+    >
+      <App />
+    </ErrorBoundary>
+  );
+}
+```
+
+## Migration Guide
+
+### From Axios
+
+```typescript
+// Before (Axios)
+const response = await axios.get('/api/users/123');
+const user = response.data;
+
+// After (@plyaz/api)
+const { data: user } = await api.getUserProfile({
+  urlPathParams: { userId: '123' }
+});
+```
+
+### From Fetch
+
+```typescript
+// Before (Fetch)
+const response = await fetch('/api/users', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify(userData)
+});
+const user = await response.json();
+
+// After (@plyaz/api)
+const { data: user } = await api.createUser({
+  body: userData
+});
+```
+
+## Contributing
+
+This package is part of the Plyaz platform. Please follow the contribution guidelines in the main repository.
+
+## Resources
+
+- [Plyaz Confluence Documentation](https://plyaz.atlassian.net/wiki/spaces/SD/pages/950316/API+Package)
+- [fetchff Documentation](https://www.npmjs.com/package/fetchff)
+- [React Query Documentation](https://tanstack.com/query)
+
+## License
+
+ISC © Plyaz

package/dist/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+// @plyaz package - Built with tsup
+
+// src/index.ts
+var PACKAGE_TEST = 1;
+
+exports.PACKAGE_TEST = PACKAGE_TEST;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAAO,IAAM,YAAA,GAAe","file":"index.cjs","sourcesContent":["export const PACKAGE_TEST = 1;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_TEST = 1;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,IAAI,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,8 @@
+// @plyaz package - Built with tsup
+
+// src/index.ts
+var PACKAGE_TEST = 1;
+
+export { PACKAGE_TEST };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;AAAO,IAAM,YAAA,GAAe","file":"index.mjs","sourcesContent":["export const PACKAGE_TEST = 1;\n"]}

package/package.json

@@ -0,0 +1,138 @@
+{
+  "name": "@plyaz/api",
+  "version": "1.0.0",
+  "description": "@plyaz/api ⚡ Core Plyaz API client enabling seamless Web3 interactions, authentication, and data access across apps and services. Built for scalability, reliability, and tokenized fan engagement experiences.",
+  "type": "module",
+  "keywords": [],
+  "packageManager": "pnpm@10.11.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=22.4.0",
+    "pnpm": ">=8.0.0"
+  },
+  "author": "Redeemer Pace",
+  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nestjs/common": "^11.1.3",
+    "@plyaz/config": "1.3.3",
+    "next": "15.4.7",
+    "react": "^19.1.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.5",
+    "@darraghor/eslint-plugin-nestjs-typed": "^6.6.2",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.15.0",
+    "@eslint/markdown": "^6.5.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@next/eslint-plugin-next": "^15.0.3",
+    "@plyaz/devtools": "^1.8.5",
+    "@plyaz/types": "^1.7.7",
+    "@types/node": "^22.14.0",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@typescript-eslint/eslint-plugin": "^8.15.0",
+    "@typescript-eslint/parser": "^8.15.0",
+    "@vitest/coverage-istanbul": "3.2.4",
+    "@vitest/coverage-v8": "^3.1.3",
+    "eslint": "^9.29.0",
+    "eslint-config-next": "^15.3.3",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-mdx": "^3.5.0",
+    "eslint-plugin-better-tailwindcss": "3.2.1",
+    "eslint-plugin-functional": "^4.4.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.13.5",
+    "eslint-plugin-jsdoc": "^50.8.0",
+    "eslint-plugin-jsonc": "^2.20.1",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-markdownlint": "^0.9.0",
+    "eslint-plugin-mdx": "^3.5.0",
+    "eslint-plugin-n": "^17.20.0",
+    "eslint-plugin-prettier": "^5.5.0",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-react": "^7.37.2",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-regexp": "^2.9.0",
+    "eslint-plugin-security": "^3.0.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-sonarjs": "^0.23.0",
+    "eslint-plugin-storybook": "^0.12.0",
+    "eslint-plugin-testing-library": "^6.5.0",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "jiti": "^2.4.2",
+    "jsdom": "^26.1.0",
+    "markdownlint": "^0.38.0",
+    "next": "15.3.3",
+    "prettier": "^3.5.3",
+    "standard-version": "^9.5.0",
+    "tailwindcss": "^4.1.8",
+    "tsup": "8.5.0",
+    "typescript": "^5",
+    "typescript-eslint": "^8.34.0",
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "3.2.4"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "pnpm clean && pnpm build:js && pnpm build:types",
+    "build:js": "tsup",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
+    "lint": "eslint ./src ./tests",
+    "lint:fix": "eslint ./src ./tests --fix",
+    "format": "prettier --write './**/*.{ts,tsx,js,jsx}'",
+    "format:check": "prettier --check './**/*.{ts,tsx,js,jsx}'",
+    "type:check": "tsc --noEmit",
+    "test": "vitest run --no-watch",
+    "test:ci": "vitest run --no-watch",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "clean": "rm -rf dist",
+    "audit": "pnpm audit",
+    "audit:moderate": "pnpm audit --audit-level moderate",
+    "audit:high": "pnpm audit --audit-level high",
+    "audit:critical": "pnpm audit --audit-level critical",
+    "audit:fix": "pnpm audit --fix",
+    "audit:enhanced": "npx audit-ci --moderate",
+    "security:check": "pnpm audit:moderate && npx audit-ci --moderate",
+    "remove:unused": "pnpm remove:unused:fnc && pnpm remove:unused:interfaces",
+    "remove:unused:interfaces": "pnpm exec ./node_modules/@plyaz/devtools/scripts/check_types.ts --remove --report=./internal-reports/unused-types-report.md",
+    "remove:unused:fnc": "pnpm exec ./node_modules/@plyaz/devtools/scripts/check_fnc.ts --report=./internal-reports/unused-declarations.md",
+    "check:dependencies": "npx tsx ./node_modules/@plyaz/devtools/scripts/check_dependencies_versions.ts --report=./internal-reports/dependency-report.md",
+    "move:types": "npx tsx ./scripts/move_types.ts src/ --report=internal-reports/moved_types.md",
+    "move:constants": "npx tsx ./node_modules/@plyaz/devtools/scripts/move_constants.ts src/ --report=internal-reports/moved_consts.md"
+  }
+}