promidas 2.0.0

package/dist/repository/protopedia-in-memory-repository.d.ts

@@ -0,0 +1,560 @@
+/**
+ * In-memory repository implementation for ProtoPedia prototypes.
+ *
+ * This module contains the concrete implementation of the repository pattern
+ * for managing ProtoPedia prototype data in memory with snapshot-based access.
+ *
+ * ## Architecture
+ *
+ * The {@link ProtopediaInMemoryRepositoryImpl} class orchestrates:
+ *
+ * - **API Client**: ProtoPedia API v2 client for fetching prototype data
+ * - **Memory Store**: {@link PrototypeInMemoryStore} for snapshot management
+ * - **Repository Interface**: {@link ProtopediaInMemoryRepository} for high-level operations
+ *
+ * ## Design Patterns
+ *
+ * ### Repository Pattern
+ * Abstracts data access behind a clean interface, isolating business logic
+ * from data fetching and storage mechanisms.
+ *
+ * ### Snapshot Isolation
+ * All read operations work against an immutable in-memory snapshot.
+ * Network I/O only occurs during explicit setup/refresh operations.
+ *
+ * ### Private Fields
+ * Uses ECMAScript private fields (#) for proper encapsulation:
+ * - `#store` - Internal memory store instance
+ * - `#apiClient` - HTTP client for ProtoPedia API
+ * - `#lastFetchParams` - Cache of last fetch parameters
+ *
+ * ## Performance Optimizations
+ *
+ * 1. **O(1) Lookups**: Direct Map access by prototype ID
+ * 2. **Hybrid Sampling**: Adaptive algorithm based on sample size ratio
+ *    - Small samples (< 50%): Set-based random selection
+ *    - Large samples (≥ 50%): Fisher-Yates shuffle
+ * 3. **Efficient Checks**: Use `store.size` instead of array operations
+ * 4. **Parameter Validation**: Zod schemas for runtime type safety
+ *
+ * ## Usage Recommendation
+ *
+ * For normal usage, import from `promidas` instead of direct instantiation:
+ * - `createPromidasForLocal()` for local development
+ * - `createPromidasForServer()` for server environments
+ * - `PromidasRepositoryBuilder` for advanced customization
+ *
+ * Direct instantiation is only recommended for:
+ * - Testing scenarios
+ * - Advanced customization needs
+ * - Framework integration
+ *
+ * @module
+ * @see {@link ProtopediaInMemoryRepository} for the public interface
+ */
+import { EventEmitter } from 'events';
+import type { ListPrototypesParams } from 'protopedia-api-v2-client';
+import type { DeepReadonly } from 'ts-essentials';
+import { ProtopediaApiCustomClient } from '../fetcher/index.js';
+import { PrototypeInMemoryStore, type PrototypeInMemoryStats, type PrototypeInMemoryStoreConfig } from '../store/index.js';
+import type { NormalizedPrototype } from '../types/index.js';
+import type { ProtopediaInMemoryRepositoryConfig, PrototypeAnalysisResult, SerializableSnapshot, SnapshotOperationResult } from './types/index.js';
+import type { ProtopediaInMemoryRepository } from './index.js';
+/**
+ * Implementation class for the ProtoPedia in-memory repository.
+ *
+ * This class provides the concrete implementation of {@link ProtopediaInMemoryRepository}
+ * with full encapsulation using ECMAScript private fields.
+ *
+ * ## Responsibilities
+ *
+ * 1. **Dependency Management**
+ *    - Receives {@link PrototypeInMemoryStore} and {@link ProtopediaApiCustomClient} via DI
+ *    - Maintains internal state for fetch parameters
+ *
+ * 2. **Snapshot Operations**
+ *    - {@link setupSnapshot} - Initial data fetch and population
+ *    - {@link refreshSnapshot} - Update snapshot with fresh API data
+ *
+ * 3. **Data Access**
+ *    - {@link getAllFromSnapshot} - Retrieve all prototypes
+ *    - {@link getPrototypeFromSnapshotByPrototypeId} - Fast ID lookup
+ *    - {@link getRandomPrototypeFromSnapshot} - Single random sample
+ *    - {@link getRandomSampleFromSnapshot} - Multiple random samples
+ *    - {@link getPrototypeIdsFromSnapshot} - Get all IDs efficiently
+ *
+ * 4. **Analysis & Metadata**
+ *    - {@link analyzePrototypes} - Statistical analysis (min/max)
+ *    - {@link getStats} - Snapshot statistics and TTL info
+ *    - {@link getConfig} - Store configuration details
+ *
+ * ## Implementation Details
+ *
+ * ### Validation
+ * All public methods validate their parameters using {@link RepositoryParamsValidator}:
+ * - {@link RepositoryParamsValidator.validatePrototypeId} - Ensures valid prototype IDs
+ * - {@link RepositoryParamsValidator.validateSampleSize} - Ensures valid sample sizes
+ *
+ * ### Error Handling
+ * Network operations return {@link SnapshotOperationResult}:
+ * - `{ ok: true, ... }` - Success with metadata
+ * - `{ ok: false, error: string }` - Failure with error message
+ *
+ * ### Performance
+ * - Uses `store.size` for O(1) empty checks
+ * - Implements hybrid sampling algorithm (see {@link SAMPLE_SIZE_THRESHOLD_RATIO})
+ * - Returns read-only data to prevent accidental mutations
+ *
+ * ## Usage
+ *
+ * **Recommended**: Import from `promidas` instead of direct instantiation
+ *
+ * **Direct instantiation** (advanced):
+ * ```typescript
+ * // Dependencies must be created manually
+ * const store = new PrototypeInMemoryStore({ ... });
+ * const client = new ProtopediaApiCustomClient({ ... });
+ *
+ * const repo = new ProtopediaInMemoryRepositoryImpl({
+ *   store,
+ *   apiClient: client
+ * });
+ * ```
+ *
+ * @see {@link ProtopediaInMemoryRepository} for the public interface contract
+ */
+export declare class ProtopediaInMemoryRepositoryImpl implements ProtopediaInMemoryRepository {
+    #private;
+    /**
+     * Event emitter for snapshot operation notifications.
+     *
+     * Only defined when enableEvents: true is set in repository configuration.
+     */
+    readonly events?: EventEmitter;
+    /**
+     * Creates a new ProtoPedia in-memory repository instance.
+     *
+     * @param dependencies - Dependency injection object
+     * @param dependencies.store - Pre-configured in-memory store instance
+     * @param dependencies.apiClient - Pre-configured API client instance
+     * @param dependencies.repositoryConfig - Repository-level configuration (optional)
+     */
+    constructor({ store, apiClient, repositoryConfig, }: {
+        store: PrototypeInMemoryStore;
+        apiClient: ProtopediaApiCustomClient;
+        repositoryConfig?: ProtopediaInMemoryRepositoryConfig;
+    });
+    /**
+     * Fetch and normalize prototypes from the ProtoPedia API.
+     *
+     * @param params - Fetch parameters to merge with {@link DEFAULT_FETCH_PARAMS}
+     * @returns {@link FetchPrototypesResult} from the API client
+     *
+     * @remarks
+     * This method delegates directly to the API client's `fetchPrototypes()` method,
+     * which handles all error cases and returns them as {@link FetchPrototypesFailure}
+     * instead of throwing exceptions.
+     *
+     * **Responsibility Separation**:
+     * - This method only fetches and normalizes data
+     * - The caller is responsible for storing the data via {@link storeSnapshot}
+     * - The caller must update lastFetchParams on successful storage
+     *
+     * **Error Handling**:
+     * - The API client never throws exceptions under normal operation
+     * - The try-catch block is defensive programming for unexpected cases
+     * - All expected errors are returned as part of {@link FetchPrototypesResult}
+     *
+     * **Logging**:
+     * - Success: `debug` level with fetch count and parameters
+     * - Failure: No logging (API client layer already logs failures)
+     * - Unexpected exceptions: `error` level (defensive fallback)
+     *
+     * @see {@link ProtopediaApiCustomClient.fetchPrototypes} for API client implementation
+     * @internal
+     */
+    private fetchAndNormalize;
+    /**
+     * Store normalized prototypes in the in-memory snapshot.
+     *
+     * This private method handles:
+     * - Storing data via the memory store
+     * - Converting store errors to {@link SetFailure}
+     * - Logging detailed operation information with sanitized data
+     *
+     * @param data - Array of normalized prototypes to store
+     * @returns {@link SetResult} - Success with stats or failure details
+     *
+     * @remarks
+     * **Error Handling**:
+     * - {@link DataSizeExceededError} → {@link SetFailure} with kind='storage_limit'
+     * - {@link SizeEstimationError} → {@link SetFailure} with kind='serialization'
+     * - Unexpected errors → {@link SetFailure} with kind='unknown'
+     *
+     * All store errors include `dataState` to indicate whether existing data was preserved.
+     *
+     * **Logging**:
+     * - Success: `debug` level with store size and data size
+     * - DataSizeExceededError: `warn` level (configuration issue)
+     * - SizeEstimationError: `error` level (serialization failure)
+     * - Unexpected errors: `error` level (unknown failures)
+     *
+     * @internal
+     */
+    private storeSnapshot;
+    /**
+     * Return the configuration used to initialize the underlying store.
+     */
+    getConfig(): Omit<Required<PrototypeInMemoryStoreConfig>, 'logger'>;
+    /**
+     * Return stats for the current snapshot from the underlying store.
+     */
+    getStats(): PrototypeInMemoryStats;
+    /**
+     * Fetch prototypes from the API and store them in memory.
+     *
+     * This is the core implementation shared by {@link setupSnapshot} and {@link refreshSnapshot}.
+     * It encapsulates the complete fetch-and-store workflow with proper error handling and
+     * optional parameter caching.
+     *
+     * @param params - Fetch parameters to merge with {@link DEFAULT_FETCH_PARAMS}
+     * @param updateLastFetchParams - Whether to update {@link #lastFetchParams} on successful storage.
+     *   Set to `true` for {@link setupSnapshot} to cache parameters for future {@link refreshSnapshot} calls.
+     *   Set to `false` for {@link refreshSnapshot} to avoid overwriting cached parameters.
+     * @returns {@link SnapshotOperationResult} indicating success or failure
+     *
+     * @remarks
+     * **Operation Flow**:
+     * 1. Fetch and normalize prototypes via {@link fetchAndNormalize}
+     * 2. Convert fetch result (both success and failure) via {@link convertFetchResult}
+     * 3. Return early if fetch failed
+     * 4. Store the fetched data in memory via {@link storeSnapshot}
+     * 5. Convert store result via {@link convertStoreResult}
+     * 6. Update {@link #lastFetchParams} only if `updateLastFetchParams` is `true` AND storage succeeds
+     *
+     * **Parameter Handling**:
+     * - Input `params` are merged with {@link DEFAULT_FETCH_PARAMS} by {@link fetchAndNormalize}
+     * - Merged parameters are cached in {@link #lastFetchParams} only when:
+     *   - `updateLastFetchParams` is `true` (typically {@link setupSnapshot})
+     *   - Storage operation succeeds
+     * - Failed operations never update {@link #lastFetchParams}
+     *
+     * **Concurrency Control**:
+     * - Uses {@link #executeWithCoalescing} to prevent concurrent API calls
+     * - Multiple concurrent calls are coalesced into a single API request
+     * - All callers receive the same result
+     * - The first caller's operation (fetch + store) is executed
+     * - Subsequent concurrent callers wait for the same result
+     * - This is necessary because async operations can run concurrently (await allows other calls to start)
+     *
+     * **Error Handling**:
+     * - Returns error result if API fetch fails (network, timeout, API errors)
+     * - Returns error result if storage fails (e.g., {@link DataSizeExceededError})
+     * - Previous snapshot remains intact on failure
+     * - Never throws exceptions - all errors are returned as {@link SnapshotOperationResult}
+     *
+     * @internal This method is private and used only by {@link setupSnapshot} and {@link refreshSnapshot}.
+     * It can be accessed in tests via `(repo as any).fetchAndStore(...)` for unit testing.
+     *
+     * @see {@link setupSnapshot} for initial snapshot setup with parameter caching
+     * @see {@link refreshSnapshot} for refreshing with cached parameters
+     */
+    private fetchAndStore;
+    /**
+     * Initialize the in-memory snapshot using the provided fetch parameters.
+     *
+     * Typically called once at startup. Fetches data from the API, stores it in memory,
+     * and caches the parameters for future {@link refreshSnapshot} calls.
+     *
+     * @param params - Fetch parameters to merge with {@link DEFAULT_FETCH_PARAMS}
+     * @returns {@link SnapshotOperationResult} indicating success or failure
+     *
+     * @remarks
+     * Delegates to {@link fetchAndStore} with `updateLastFetchParams: true`.
+     * Emits `snapshotStarted('setup')` event before operation (if events enabled).
+     *
+     * See {@link fetchAndStore} for operation flow, concurrency control, and error handling details.
+     *
+     * @see {@link fetchAndStore}
+     * @see {@link refreshSnapshot}
+     */
+    setupSnapshot(params: ListPrototypesParams): Promise<SnapshotOperationResult>;
+    /**
+     * Refresh the in-memory snapshot using cached fetch parameters.
+     *
+     * Typically called periodically to refresh expired data. Uses parameters
+     * cached by the last successful {@link setupSnapshot} call.
+     *
+     * **Prerequisite**: {@link setupSnapshot} must have been called successfully at least once.
+     * If called before {@link setupSnapshot}, returns an error with code `REPOSITORY_INVALID_STATE`.
+     *
+     * @returns Promise resolving to {@link SnapshotOperationResult}:
+     * - **Success** (`ok: true`): Contains {@link PrototypeInMemoryStats} with snapshot metadata
+     * - **Failure** (`ok: false`): One of:
+     *   - {@link RepositorySnapshotFailure} - Invalid state (setupSnapshot not called)
+     *   - {@link FetcherSnapshotFailure} - Network/HTTP errors from API
+     *   - {@link StoreSnapshotFailure} - Storage errors (size limits, serialization)
+     *   - {@link UnknownSnapshotFailure} - Unexpected errors
+     *
+     * @remarks
+     * **Operation Flow**:
+     * 1. Validate that {@link setupSnapshot} has been called (check `#lastFetchParams`)
+     * 2. Return error immediately if validation fails (before coalescing)
+     * 3. Emit `snapshotStarted('refresh')` event (if events enabled)
+     * 4. Delegate to {@link fetchAndStore} with `updateLastFetchParams: false`
+     * 5. Preserve existing snapshot on failure (atomic operation)
+     *
+     * **Concurrency Control**:
+     * - Multiple concurrent calls are coalesced into a single API request
+     * - All callers receive the same result
+     * - Validation check executes before coalescing, ensuring deterministic failure
+     *
+     * **Error Handling**:
+     * - Never throws exceptions
+     * - All errors returned as Result type with `ok: false`
+     * - Use `result.origin` to discriminate error types
+     *
+     * @example
+     * ```typescript
+     * // Typical usage: periodic refresh
+     * const result = await repo.refreshSnapshot();
+     * if (result.ok) {
+     *   console.log(`Refreshed ${result.stats.size} prototypes`);
+     * } else {
+     *   console.error(`Refresh failed: ${result.message}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Error handling by origin
+     * const result = await repo.refreshSnapshot();
+     * if (!result.ok) {
+     *   if (result.origin === 'repository') {
+     *     console.error('Call setupSnapshot first');
+     *   } else if (result.origin === 'fetcher') {
+     *     console.error(`HTTP ${result.status}: ${result.message}`);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link fetchAndStore} - Core implementation
+     * @see {@link setupSnapshot} - Initial snapshot setup
+     * @see {@link SnapshotOperationResult} - Return type details
+     */
+    refreshSnapshot(): Promise<SnapshotOperationResult>;
+    /**
+     * Load and validate snapshot data, then store it in memory.
+     *
+     * This is the core implementation for {@link setupSnapshotFromSerializedData}.
+     * It encapsulates the complete validation-and-store workflow with proper error handling.
+     *
+     * @param data - Serializable snapshot object to validate and store
+     * @returns {@link SnapshotOperationResult} indicating success or failure
+     *
+     * @remarks
+     * **Operation Flow**:
+     * 1. Validate data structure via {@link validateSerializableSnapshot}
+     * 2. Return early if validation failed (origin: 'repository')
+     * 3. Store the validated prototypes via {@link storeSnapshot}
+     * 4. Return success or store failure result
+     *
+     * **Concurrency Control**:
+     * Unlike {@link fetchAndStore}, this method does NOT use concurrency control because:
+     * - This is a synchronous method (no await points)
+     * - JavaScript's single-threaded nature prevents concurrent execution
+     * - Multiple calls will execute sequentially, not simultaneously
+     * - Each call will update the store in order
+     *
+     * **Error Handling**:
+     * - Returns {@link RepositorySnapshotFailure} if validation fails
+     * - Returns {@link StoreSnapshotFailure} if storage fails (e.g., {@link DataSizeExceededError})
+     * - Previous snapshot remains intact on failure
+     * - Never throws exceptions - all errors are returned as {@link SnapshotOperationResult}
+     *
+     * **Logging**:
+     * - Validation: Handled by {@link validateSerializableSnapshot}
+     * - Storage success: Handled by {@link storeSnapshot} at `debug` level
+     * - Storage failure: Handled by {@link storeSnapshot}
+     *
+     * @internal
+     * This method is private and used only by {@link setupSnapshotFromSerializedData}.
+     *
+     * @see {@link setupSnapshotFromSerializedData} - Public API
+     * @see {@link validateSerializableSnapshot} - Validation logic
+     * @see {@link storeSnapshot} - Storage implementation
+     * @see {@link fetchAndStore} - Async equivalent with concurrency control
+     */
+    private loadAndStore;
+    /**
+     * Setup snapshot from previously serialized data.
+     *
+     * Alternative to {@link setupSnapshot} for offline/cached initialization.
+     * Validates the data structure and populates the in-memory store.
+     *
+     * **Important**: This method resets `#lastFetchParams` to `undefined`, preventing
+     * {@link refreshSnapshot} from working until {@link setupSnapshot} is called.
+     * This ensures that API parameters don't become mismatched with serialized data.
+     *
+     * @param data - Serializable snapshot object (previously exported via {@link getSerializableSnapshot})
+     * @returns {@link SnapshotOperationResult} indicating success or failure
+     *
+     * @remarks
+     * **Caller Responsibilities**:
+     * - Load snapshot file (e.g., `fs.readFile()`)
+     * - Parse JSON to JavaScript object (e.g., `JSON.parse()`)
+     * - Pass the parsed object to this method
+     *
+     * **Operation Flow**:
+     * 1. Reset `#lastFetchParams` to `undefined`
+     * 2. Emit `snapshotStarted('setupFromSerializedData')` event (if enabled)
+     * 3. Validate data structure via {@link loadAndStore}
+     * 4. Store validated prototypes if validation succeeds
+     * 5. Return operation result
+     *
+     * **Side Effects**:
+     * - Resets cached API fetch parameters
+     * - Subsequent {@link refreshSnapshot} calls will fail with `REPOSITORY_INVALID_STATE`
+     * - Use {@link setupSnapshot} after this method to re-enable {@link refreshSnapshot}
+     *
+     * **This method does NOT**:
+     * - Perform file I/O operations
+     * - Parse JSON strings
+     * - Make network requests
+     *
+     * @example
+     * ```typescript
+     * // Import from file
+     * const json = await fs.readFile('snapshot.json', 'utf-8');
+     * const data = JSON.parse(json);
+     * const result = repo.setupSnapshotFromSerializedData(data);
+     *
+     * if (result.ok) {
+     *   console.log(`Loaded ${result.stats.size} prototypes`);
+     * } else {
+     *   console.error(`Import failed: ${result.message}`);
+     * }
+     * ```
+     *
+     * @see {@link loadAndStore} for the core implementation
+     * @see {@link getSerializableSnapshot} for exporting snapshots
+     * @see {@link setupSnapshot} for API-based initialization
+     */
+    setupSnapshotFromSerializedData(data: SerializableSnapshot): SnapshotOperationResult;
+    /**
+     * Get current snapshot as a serializable object.
+     *
+     * Returns a plain JavaScript object containing all prototypes from the current
+     * snapshot along with metadata. The returned object can be passed to
+     * JSON.stringify() for persistence.
+     *
+     * This method does NOT perform file I/O or JSON.stringify().
+     * The caller is responsible for serialization and storage.
+     *
+     * @returns Serializable snapshot object with version, timestamp, and prototypes
+     *
+     * @example
+     * ```typescript
+     * // Export to file
+     * const snapshot = repo.getSerializableSnapshot();
+     * const json = JSON.stringify(snapshot, null, 2);
+     * await fs.writeFile('snapshot.json', json, 'utf-8');
+     * ```
+     */
+    getSerializableSnapshot(): SerializableSnapshot;
+    /**
+     * Look up a prototype by id in the current snapshot.
+     * Never performs HTTP requests.
+     *
+     * @param prototypeId - The prototype ID to look up. Must be a positive integer.
+     * @returns The prototype if found, null otherwise
+     * @throws {ValidationError} If prototypeId is not a positive integer
+     */
+    getPrototypeFromSnapshotByPrototypeId(prototypeId: number): Promise<DeepReadonly<NormalizedPrototype> | null>;
+    /**
+     * Return a random prototype from the current snapshot, or null
+     * when the snapshot is empty. Never performs HTTP requests.
+     *
+     * @remarks
+     * **Implementation Note**: This method uses `store.size` for O(1) empty check,
+     * then `store.getAll()` to select a random element. While it might seem wasteful
+     * to copy all objects just to select one, the alternative would require:
+     *
+     * 1. Call `getPrototypeIds()` - O(n) to iterate Map keys
+     * 2. Select random ID - O(1)
+     * 3. Call `getByPrototypeId(id)` - O(1)
+     *
+     * This approach still costs O(n) for step 1, making it no better than
+     * `getAll()` in terms of time complexity, but with additional function
+     * call overhead. The current implementation is simpler and equally
+     * efficient.
+     */
+    getRandomPrototypeFromSnapshot(): Promise<DeepReadonly<NormalizedPrototype> | null>;
+    /**
+     * Return random samples from the current snapshot.
+     *
+     * Returns up to `size` random prototypes without duplicates.
+     * If `size` exceeds the available data, returns all prototypes in random order.
+     * Never performs HTTP requests.
+     *
+     * @param size - Maximum number of samples to return. Must be an integer.
+     * @returns Array of random prototypes (empty array if size <= 0 or snapshot is empty)
+     * @throws {ValidationError} If size is not an integer
+     *
+     * @remarks
+     * **Implementation Note**: Uses a hybrid approach for optimal performance:
+     *
+     * - `store.size` provides O(1) empty check
+     * - `store.getAll()` is O(1) (returns reference to internal array)
+     * - For small samples (< 50% of total): Set-based random selection, O(size)
+     * - For large samples (≥ 50% of total): Fisher-Yates shuffle, O(n)
+     *
+     * This hybrid approach optimizes for the common case where sample size is
+     * much smaller than the total population, while avoiding performance
+     * degradation when the sample size approaches the total size.
+     */
+    getRandomSampleFromSnapshot(size: number): Promise<readonly DeepReadonly<NormalizedPrototype>[]>;
+    /**
+     * Return all prototype IDs from the current snapshot.
+     * Never performs HTTP requests.
+     */
+    getPrototypeIdsFromSnapshot(): Promise<readonly number[]>;
+    /**
+     * Return all prototypes from the current snapshot.
+     * Never performs HTTP requests.
+     */
+    getAllFromSnapshot(): Promise<readonly DeepReadonly<NormalizedPrototype>[]>;
+    /**
+     * Analyze prototypes to extract ID range (minimum and maximum).
+     *
+     * Uses a for-loop implementation for better performance with large datasets (5,000+ items).
+     * Single-pass algorithm with minimal memory allocations.
+     *
+     * @param prototypes - Array of prototypes to analyze
+     * @returns Object containing min and max IDs, or null values if array is empty
+     */
+    analyzePrototypesWithForLoop(prototypes: readonly DeepReadonly<NormalizedPrototype>[]): PrototypeAnalysisResult;
+    /**
+     * Analyze prototypes from the current snapshot to extract ID range.
+     *
+     * Currently uses the for-loop implementation for optimal performance with typical dataset sizes.
+     * Never performs HTTP requests.
+     *
+     * @returns Object containing min and max IDs, or null values if snapshot is empty
+     */
+    analyzePrototypes(): Promise<PrototypeAnalysisResult>;
+    /**
+     * Clean up event listeners and release resources.
+     *
+     * Removes all event listeners from the internal EventEmitter to prevent memory leaks.
+     * Safe to call even when events are disabled.
+     *
+     * @remarks
+     * Always call this method in cleanup paths:
+     * - Test cleanup (afterEach)
+     * - Component unmounting (React useEffect cleanup)
+     * - Before creating a new repository instance
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=protopedia-in-memory-repository.d.ts.map

package/dist/repository/protopedia-in-memory-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protopedia-in-memory-repository.d.ts","sourceRoot":"","sources":["../../lib/repository/protopedia-in-memory-repository.ts"],"names":[],"mappings":"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"}