@fjell/cache 4.6.11 → 4.6.13

package/README.md

@@ -0,0 +1,96 @@
+# Fjell Cache
+
+Cache for Fjell - A powerful caching framework for TypeScript applications
+
+## Overview
+
+Fjell Cache provides intelligent caching capabilities for complex data models and business relationships. Built on the Fjell framework architecture, it offers high-performance caching with automatic relationship management and business logic integration.
+
+## Features
+
+- **Smart Caching**: Intelligent cache operations with automatic cache hits/misses
+- **Business Relationships**: Automatic population of related entities through aggregation
+- **Performance Optimized**: High-performance cache operations with bulk processing
+- **Location-Based**: Support for contained items with location hierarchies
+- **Framework Integration**: Seamless integration with Fjell Core, Registry, and Client API
+- **TypeScript First**: Full TypeScript support with comprehensive type safety
+
+## Installation
+
+```bash
+npm install @fjell/cache
+# or
+pnpm add @fjell/cache
+# or
+yarn add @fjell/cache
+```
+
+## Quick Start
+
+```typescript
+import { createCache } from '@fjell/cache';
+import { createCoordinate, createRegistry } from '@fjell/registry';
+import { ClientApi } from '@fjell/client-api';
+
+// Create a registry for cache management
+const registry = createRegistry();
+
+// Create a cache instance with API integration
+const userApi = createUserApi(); // Your API implementation
+const userCache = await createCache(userApi, createCoordinate('user'), registry);
+
+// Perform cache operations
+const [cacheMap, allUsers] = await userCache.operations.all();
+const [, cachedUser] = await userCache.operations.get(userKey);
+const [, retrievedUser] = await userCache.operations.retrieve(userKey); // Cache hit!
+
+await userCache.operations.set(userKey, updatedUser);
+```
+
+## Core Components
+
+### Basic Caching
+- **Cache Operations**: Get, set, retrieve, and manage cached data
+- **Cache-as-Instance**: Caches extend Instance from fjell-registry
+- **Performance Monitoring**: Track cache hits, misses, and efficiency
+
+### Advanced Aggregation
+- **Entity Relationships**: Automatic population of related entities
+- **Required vs Optional**: Flexible relationship management
+- **Business Logic**: Complex business scenarios with interconnected data
+
+### Direct Cache Management
+- **CacheMap**: Low-level cache operations and management
+- **Location Filtering**: Filter contained items by location hierarchy
+- **Bulk Operations**: Efficient processing of multiple cache operations
+
+## Examples
+
+Comprehensive examples are available in the [examples directory](./examples/):
+
+- **[Basic Cache Example](./examples/basic-cache-example.ts)** - Start here! Fundamental caching operations
+- **[Aggregator Example](./examples/aggregator-example.ts)** - Advanced business relationships
+- **[Cache Map Example](./examples/cache-map-example.ts)** - Low-level cache operations
+
+## Documentation
+
+For detailed documentation, examples, and API reference, visit our [documentation site](https://getfjell.github.io/fjell-cache/).
+
+## Dependencies
+
+Fjell Cache builds on the Fjell ecosystem:
+- `@fjell/core` - Core framework functionality
+- `@fjell/registry` - Registry and coordinate management
+- `@fjell/client-api` - API integration layer
+- `@fjell/http-api` - HTTP API capabilities
+- `@fjell/logging` - Structured logging
+
+## License
+
+Apache-2.0
+
+## Contributing
+
+We welcome contributions! Please see our contributing guidelines for more information.
+
+Built with love by the Fjell team.

package/docs/docs.config.ts

@@ -0,0 +1,75 @@
+interface DocsConfig {
+  projectName: string;
+  basePath: string;
+  port: number;
+  branding: {
+    theme: string;
+    tagline: string;
+    logo?: string;
+    backgroundImage?: string;
+    primaryColor?: string;
+    accentColor?: string;
+    github?: string;
+    npm?: string;
+  };
+  sections: Array<{
+    id: string;
+    title: string;
+    subtitle: string;
+    file: string;
+  }>;
+  filesToCopy: Array<{
+    source: string;
+    destination: string;
+  }>;
+  plugins?: any[];
+  version: {
+    source: string;
+  };
+  customContent?: {
+    [key: string]: (content: string) => string;
+  };
+}
+
+const config: DocsConfig = {
+  projectName: 'Fjell Cache',
+  basePath: '/fjell-cache/',
+  port: 3005,
+  branding: {
+    theme: 'cache',
+    tagline: 'Cache for Fjell',
+    backgroundImage: '/pano.png',
+    github: 'https://github.com/getfjell/fjell-cache',
+    npm: 'https://www.npmjs.com/package/@fjell/cache'
+  },
+  sections: [
+    {
+      id: 'overview',
+      title: 'Getting Started',
+      subtitle: 'Installation, setup & core concepts',
+      file: '/README.md'
+    },
+    {
+      id: 'examples',
+      title: 'Examples',
+      subtitle: 'Code examples & usage patterns',
+      file: '/examples-README.md'
+    }
+  ],
+  filesToCopy: [
+    {
+      source: '../README.md',
+      destination: 'public/README.md'
+    },
+    {
+      source: '../examples/README.md',
+      destination: 'public/examples-README.md'
+    }
+  ],
+  plugins: [],
+  version: {
+    source: 'package.json'
+  }
+}
+
+export default config

package/docs/index.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <link rel="icon" type="image/svg+xml" href="/fjell-icon.svg" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Fjell Cache - Cache for Fjell</title>
+  <meta name="description"
+    content="Cache for Fjell - A powerful caching framework for TypeScript applications with intelligent caching and business relationships">
+</head>
+
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+
+</html>

package/docs/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "fjell-cache-docs",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "copy-docs": "node node_modules/@fjell/docs-template/scripts/copy-docs.js",
+    "dev": "pnpm run copy-docs && vite",
+    "build": "pnpm run copy-docs && vite build",
+    "preview": "vite preview",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest --watch"
+  },
+  "dependencies": {
+    "@fjell/docs-template": "1.0.5",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "@vitejs/plugin-react": "^4.6.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "jsdom": "^26.1.0",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.0",
+    "vitest": "^3.2.4"
+  }
+}

package/docs/public/README.md

@@ -0,0 +1,96 @@
+# Fjell Cache
+
+Cache for Fjell - A powerful caching framework for TypeScript applications
+
+## Overview
+
+Fjell Cache provides intelligent caching capabilities for complex data models and business relationships. Built on the Fjell framework architecture, it offers high-performance caching with automatic relationship management and business logic integration.
+
+## Features
+
+- **Smart Caching**: Intelligent cache operations with automatic cache hits/misses
+- **Business Relationships**: Automatic population of related entities through aggregation
+- **Performance Optimized**: High-performance cache operations with bulk processing
+- **Location-Based**: Support for contained items with location hierarchies
+- **Framework Integration**: Seamless integration with Fjell Core, Registry, and Client API
+- **TypeScript First**: Full TypeScript support with comprehensive type safety
+
+## Installation
+
+```bash
+npm install @fjell/cache
+# or
+pnpm add @fjell/cache
+# or
+yarn add @fjell/cache
+```
+
+## Quick Start
+
+```typescript
+import { createCache } from '@fjell/cache';
+import { createCoordinate, createRegistry } from '@fjell/registry';
+import { ClientApi } from '@fjell/client-api';
+
+// Create a registry for cache management
+const registry = createRegistry();
+
+// Create a cache instance with API integration
+const userApi = createUserApi(); // Your API implementation
+const userCache = await createCache(userApi, createCoordinate('user'), registry);
+
+// Perform cache operations
+const [cacheMap, allUsers] = await userCache.operations.all();
+const [, cachedUser] = await userCache.operations.get(userKey);
+const [, retrievedUser] = await userCache.operations.retrieve(userKey); // Cache hit!
+
+await userCache.operations.set(userKey, updatedUser);
+```
+
+## Core Components
+
+### Basic Caching
+- **Cache Operations**: Get, set, retrieve, and manage cached data
+- **Cache-as-Instance**: Caches extend Instance from fjell-registry
+- **Performance Monitoring**: Track cache hits, misses, and efficiency
+
+### Advanced Aggregation
+- **Entity Relationships**: Automatic population of related entities
+- **Required vs Optional**: Flexible relationship management
+- **Business Logic**: Complex business scenarios with interconnected data
+
+### Direct Cache Management
+- **CacheMap**: Low-level cache operations and management
+- **Location Filtering**: Filter contained items by location hierarchy
+- **Bulk Operations**: Efficient processing of multiple cache operations
+
+## Examples
+
+Comprehensive examples are available in the [examples directory](./examples/):
+
+- **[Basic Cache Example](./examples/basic-cache-example.ts)** - Start here! Fundamental caching operations
+- **[Aggregator Example](./examples/aggregator-example.ts)** - Advanced business relationships
+- **[Cache Map Example](./examples/cache-map-example.ts)** - Low-level cache operations
+
+## Documentation
+
+For detailed documentation, examples, and API reference, visit our [documentation site](https://getfjell.github.io/fjell-cache/).
+
+## Dependencies
+
+Fjell Cache builds on the Fjell ecosystem:
+- `@fjell/core` - Core framework functionality
+- `@fjell/registry` - Registry and coordinate management
+- `@fjell/client-api` - API integration layer
+- `@fjell/http-api` - HTTP API capabilities
+- `@fjell/logging` - Structured logging
+
+## License
+
+Apache-2.0
+
+## Contributing
+
+We welcome contributions! Please see our contributing guidelines for more information.
+
+Built with love by the Fjell team.

package/docs/public/examples-README.md

@@ -0,0 +1,302 @@
+# Fjell-Cache Examples
+
+This directory contains examples demonstrating how to use fjell-cache for caching data models and managing complex business relationships with different patterns and complexity levels.
+
+## Examples
+
+### 1. `basic-cache-example.ts` ⭐ **Start Here!**
+**Perfect for beginners!** Demonstrates the fundamental way to use fjell-cache for data caching:
+- **Basic cache operations** - Create caches with coordinates and registries, use operations API
+- **Simple data models** - User and Task entities with mock storage
+- **Cache-as-Instance architecture** - Caches extend Instance from fjell-registry
+- **Cache hits vs misses** - Understand cache behavior and performance benefits
+- **Cache management** - Updates, deletions, and data consistency through operations
+
+Great for understanding the fundamentals of fjell-cache data management.
+
+### 2. `aggregator-example.ts` 🏗️ **Advanced Business Relationships**
+**Complete business relationship management!** Demonstrates advanced caching patterns with entity relationships:
+- **Multiple interconnected models**: Customer, Order, Product, SupportTicket
+- **Automatic reference population**: Orders automatically include customer data
+- **Required vs optional aggregates**: Flexible relationship management
+- **Complex business scenarios**: E-commerce platform with customer management
+- **Performance optimization**: Cache efficiency through aggregated data
+
+Shows how fjell-cache handles enterprise data relationship patterns.
+
+### 3. `cache-map-example.ts` 🔧 **Low-Level Cache Operations**
+**Direct cache management!** Demonstrates lower-level CacheMap functionality:
+- **Direct CacheMap usage**: Create and manage cache maps without higher-level abstractions
+- **Primary and composite keys**: Handle both simple and complex key structures
+- **Location-based operations**: Filter contained items by location hierarchy
+- **Performance characteristics**: Bulk operations and efficiency testing
+- **Cache lifecycle**: Cloning, cleanup, and memory management
+
+Perfect for understanding the underlying cache mechanisms and advanced use cases.
+
+## Key Concepts Demonstrated
+
+### Basic Caching Operations (basic-cache-example.ts)
+```typescript
+// Import fjell-cache functionality
+import { createCache } from '@fjell/cache';
+import { createCoordinate, createRegistry } from '@fjell/registry';
+import { ClientApi } from '@fjell/client-api';
+
+// Create a registry for cache management
+const registry = createRegistry();
+
+// Create a cache instance with API integration
+const userApi = createUserApi(); // Your API implementation
+const userCache = await createCache(userApi, createCoordinate('user'), registry);
+
+// Cache is now an instance - no need for separate createInstance call
+// Perform cache operations through the operations API
+const [cacheMap, allUsers] = await userCache.operations.all();
+const [, cachedUser] = await userCache.operations.get(userKey);
+const [, retrievedUser] = await userCache.operations.retrieve(userKey); // Cache hit!
+
+await userCache.operations.set(userKey, updatedUser);
+```
+
+### Advanced Aggregation (aggregator-example.ts)
+```typescript
+// Create aggregated cache with relationships
+const orderAggregator = await createAggregator(orderCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false }, // Required reference
+    product: { cache: productCache, optional: true },    // Optional reference
+  },
+  events: {}
+});
+
+// Automatically populate related entities
+const populatedOrder = await orderAggregator.populate(order);
+if (populatedOrder.aggs?.customer?.item) {
+  const customer = populatedOrder.aggs.customer.item;
+  console.log(`Order for: ${customer.name} (${customer.email})`);
+}
+
+// Aggregator is now itself an instance - access operations directly
+const [, orders] = await orderAggregator.all();
+```
+
+### Direct Cache Management (cache-map-example.ts)
+```typescript
+// Create CacheMap instances directly
+const documentCacheMap = new CacheMap<Document, 'document'>(['document']);
+const commentCacheMap = new CacheMap<Comment, 'comment', 'document'>(['comment', 'document']);
+
+// Basic operations
+documentCacheMap.set(documentKey, document);
+const retrievedDoc = documentCacheMap.get(documentKey);
+const hasDoc = documentCacheMap.includesKey(documentKey);
+
+// Bulk operations
+const allDocuments = documentCacheMap.allIn([]);
+const allKeys = documentCacheMap.keys();
+const allValues = documentCacheMap.values();
+
+// Location-based filtering for contained items
+const commentsInDoc = commentCacheMap.allIn([{ kt: 'document', lk: documentId }]);
+
+// Performance operations
+const clonedCache = documentCacheMap.clone();
+documentCacheMap.delete(documentKey);
+```
+
+### Data Model Patterns
+
+#### Primary Items
+- Standalone entities (User, Customer, Document)
+- No location hierarchy constraints
+- Simple key structure: `Item<'keyType'>`
+
+#### Contained Items
+- Nested within other entities or locations
+- Multi-level location keys for organization
+- Complex key structure: `Item<'keyType', 'location1', 'location2', ...>`
+
+#### Aggregated Items
+- Items with automatic reference population
+- Business relationships through cache aggregation
+- Performance optimized through cached references
+
+## Running Examples
+
+```bash
+# Start with the basic example (recommended)
+npx tsx examples/basic-cache-example.ts
+
+# Run the aggregator example
+npx tsx examples/aggregator-example.ts
+
+# Run the cache map example
+npx tsx examples/cache-map-example.ts
+
+# Or with Node.js
+node -r esbuild-register examples/basic-cache-example.ts
+```
+
+## Integration with Real Applications
+
+All examples use the actual fjell-cache functionality! In production applications:
+
+```typescript
+import { createCache, createRegistry, createInstance, createAggregator } from '@fjell/cache';
+import { ClientApi } from '@fjell/client-api';
+
+// Basic cache setup
+const registry = createRegistry();
+
+const userCache = await createCache(userApi, 'user');
+const userInstance = createInstance(registry, createCoordinate('user'), userCache);
+
+// With aggregation for business relationships
+const orderAggregator = await createAggregator(orderCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false },
+    items: { cache: productCache, optional: true }
+  },
+  events: {
+    orderUpdated: async (key, item) => {
+      // Custom event handling
+      await notifyCustomer(item);
+    }
+  }
+});
+
+// Advanced cache configuration
+const options = {
+  cacheSize: 10000,
+  ttl: 3600000, // 1 hour
+  refreshThreshold: 0.8,
+  compression: true
+};
+```
+
+## Cache Operation Types
+
+### Basic Operations
+- **all()**: Get all items and update cache
+- **get()**: Get item by key, fetch from API if not cached
+- **retrieve()**: Get item by key, return null if not cached
+- **set()**: Store item in cache
+- **one()**: Get single item
+- **find()**: Search items with finder methods
+
+### Aggregation Operations
+- **populate()**: Automatically populate item with related entities
+- **populateAggregate()**: Populate specific aggregate relationship
+- **populateEvent()**: Handle population events
+
+### Cache Management
+- **allIn()**: Get items by location (for contained items)
+- **queryIn()**: Query items by location with filtering
+- **clone()**: Create independent cache copy
+- **delete()**: Remove item from cache
+- **clear()**: Clear all cache contents
+
+### Business Operations
+```typescript
+// Cache with business logic integration
+const cache = await createCache(api, 'order', {
+  hooks: {
+    beforeGet: async (key) => { /* validation */ },
+    afterSet: async (key, item) => { /* notifications */ }
+  },
+  validators: {
+    status: (status) => ['pending', 'shipped', 'delivered'].includes(status)
+  },
+  aggregates: {
+    customer: customerCache,
+    items: productCache
+  }
+});
+```
+
+## When to Use What
+
+**Use `basic-cache-example.ts` approach when:**
+- Learning fjell-cache fundamentals
+- Building simple applications with caching needs
+- Need basic get/set cache operations
+- Working with independent data models
+
+**Use `aggregator-example.ts` approach when:**
+- Managing complex business relationships
+- Need automatic population of related entities
+- Building enterprise applications with interconnected data
+- Require performance optimization through aggregated caching
+- Working with customer/order/product type relationships
+
+**Use `cache-map-example.ts` approach when:**
+- Need direct control over cache operations
+- Building custom caching solutions
+- Working with contained items and location hierarchies
+- Require maximum performance and minimal overhead
+- Implementing cache-based data structures
+
+## Advanced Features
+
+### Cache Aggregation
+```typescript
+// Complex aggregation with optional and required references
+const ticketAggregator = await createAggregator(ticketCache, {
+  aggregates: {
+    customer: { cache: customerCache, optional: false },    // Always populated
+    order: { cache: orderCache, optional: true },           // Only if orderId exists
+    assignee: { cache: userCache, optional: true }          // Only if assigned
+  },
+  events: {
+    ticketAssigned: async (key, ticket) => {
+      await notifyAssignee(ticket);
+    }
+  }
+});
+
+// Automatic population includes all available references
+const populatedTicket = await ticketAggregator.populate(ticket);
+```
+
+### Performance Optimization
+```typescript
+// Cache with coordinate and registry
+const cache = await createCache(api, createCoordinate('product'), registry);
+
+// Bulk operations for efficiency
+const [cacheMap, allProducts] = await cache.operations.all();
+const productMap = new Map(allProducts.map(p => [p.id, p]));
+
+// Access cache properties for optimization
+console.log(`Cache coordinate: ${cache.coordinate.kta.join(', ')}`);
+console.log(`Cached items: ${cache.cacheMap.size()}`);
+```
+
+### Storage Integration
+Fjell-cache works with any storage backend through the ClientApi interface:
+- SQL databases (PostgreSQL, MySQL, SQLite)
+- NoSQL databases (MongoDB, DynamoDB, Redis)
+- REST APIs and GraphQL endpoints
+- In-memory stores and mock data
+- File systems and cloud storage
+- Custom data sources
+
+### Error Handling and Resilience
+```typescript
+// Cache with proper error handling through the API layer
+const resilientCache = await createCache(api, createCoordinate('user'), registry);
+
+// Error handling in operations
+try {
+  const [, user] = await resilientCache.operations.get(userKey);
+  return user;
+} catch (error) {
+  // Handle cache errors gracefully
+  console.error('Cache operation failed:', error);
+  // Fallback to direct API call
+  return await api.get(userKey);
+}
+```
+
+This provides the foundation for building scalable, maintainable applications with intelligent caching using fjell-cache.

package/docs/src/index.css

@@ -0,0 +1,3 @@
+/* Custom styles for fjell-cache docs */
+
+/* Additional styles can be added here to customize the cache theme */

package/docs/src/main.tsx

@@ -0,0 +1,12 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { DocsApp } from '@fjell/docs-template'
+import '@fjell/docs-template/dist/index.css'
+import config from '../docs.config'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <DocsApp config={config} />
+  </React.StrictMode>
+)

package/docs/src/test/setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom'

package/docs/tsconfig.node.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "noEmit": true
+  },
+  "include": [
+    "vite.config.ts",
+    "docs.config.ts"
+  ]
+}

package/examples/aggregator-example.ts

@@ -128,6 +128,7 @@ const createSupportTicket = (
   priority: 'low' | 'medium' | 'high' | 'urgent',
   status: 'open' | 'in-progress' | 'resolved' | 'closed',
   description: string,
+  // eslint-disable-next-line max-params
   orderId?: string): SupportTicket => {
   const ticket: SupportTicket = {
     id, customerId, subject, priority, status, description, orderId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/cache",
   "description": "Cache for Fjell",
-  "version": "4.6.11",
+  "version": "4.6.13",
   "keywords": [
     "cache",
     "fjell"
@@ -19,21 +19,22 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.7",
-    "@fjell/core": "^4.4.7",
-    "@fjell/http-api": "^4.4.5",
-    "@fjell/logging": "^4.4.7",
-    "@fjell/registry": "^4.4.11"
+    "@fjell/client-api": "^4.4.13",
+    "@fjell/core": "^4.4.13",
+    "@fjell/http-api": "^4.4.16",
+    "@fjell/logging": "^4.4.17",
+    "@fjell/registry": "^4.4.16"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.31.0",
-    "@swc/core": "^1.13.1",
+    "@fjell/eslint-config": "^1.0.5",
+    "@swc/core": "^1.13.2",
     "@tsconfig/recommended": "^1.0.10",
     "@types/multer": "^2.0.0",
-    "@types/node": "^24.0.15",
-    "@typescript-eslint/eslint-plugin": "^8.37.0",
-    "@typescript-eslint/parser": "^8.37.0",
+    "@types/node": "^24.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "concurrently": "^9.2.0",
@@ -58,6 +59,10 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --ext .ts --fix",
     "clean": "rimraf dist",
-    "test": "pnpm run lint && vitest run --coverage"
+    "test": "pnpm run lint && vitest run --coverage",
+    "docs:dev": "cd docs && pnpm run dev",
+    "docs:build": "cd docs && pnpm run build",
+    "docs:preview": "cd docs && pnpm run preview",
+    "docs:test": "cd docs && pnpm run test"
   }
 }

package/vitest.config.ts

@@ -21,7 +21,7 @@ export default defineConfig({
       thresholds: {
         lines: 89,
         functions: 85,
-        branches: 93,
+        branches: 92,
         statements: 89,
       },
     },