@intellegens/cornerstone-client 0.0.44 → 0.0.9999-alpha-1

package/README.md

@@ -30,28 +30,35 @@ http://localhost:3000
 
 ### API Initialization service
 
-This service provides way to load API configuration for a Cornerstone client application:
+This service provides a centralized way to initialize API configuration for a Cornerstone client application, including automatic API base URL detection and shared settings fetching:
 
 ```ts
 import { ApiInitializationService } from '@intellegens/cornerstone-client';
 const apiInitializationService = new ApiInitializationService();
-await apiInitializationService.initialize();
+await apiInitializationService.initializeAsync();
 ```
 
 or use the existing singleton instance
 
 ```ts
 import { apiInitializationService } from '@intellegens/cornerstone-client';
-await apiInitializationService.initialize();
+await apiInitializationService.initializeAsync();
 ```
 
+#### Key Features
+
+- **API Base URL Detection**: Automatically detects the API base URL through multiple methods
+- **Shared Settings Management**: Fetches and caches server-side configuration that's safe to share with clients
+- **HTTP Service Configuration**: Allows customization of the global HTTP service
+- **Automatic Initialization**: Handles both API detection and configuration fetching in a single call
+
 It also provides a way of customizing global defaults for Cornerstone client application:
 
 - `httpService` Configures a default HTTP Service to be used across the application, unless specified otherwise (See [HTTP Service Abstraction](#http-service-abstraction))
 
 ```ts
 import { apiInitializationService, FetchHttpService } from '@intellegens/cornerstone-client';
-await apiInitializationService.initialize({
+await apiInitializationService.initializeAsync({
   httpService: new FetchHttpService(),
 });
 ```
@@ -67,16 +74,66 @@ Base API URL is detected by checking the `CORNERSTONE-API-BASEURL` response head
 Before, or after the base API URL has been detected, you can get any API endpoint URL by calling:
 
 ```ts
-const fetchUrl = `${await apiInitializationService.getApiUrl('/my/endpoint')}`;
+const fetchUrl = `${await apiInitializationService.getApiUrlAsync('/my/endpoint')}`;
+```
+
+#### Shared Settings Access
+
+After initialization, you can access server-side configuration that's been shared with the client:
+
+```ts
+// Get cached app settings
+const settings = apiInitializationService.appConfig;
+```
+
+The app shared settings contain only client-safe configuration properties as defined by the server-side `AppSettingsShared` class, plus any additional runtime settings. Sensitive server-only settings are never exposed to clients.
+
+### ~~System Service~~ (Deprecated)
+
+> **Note**: The SystemService has been deprecated and its functionality has been integrated into the ApiInitializationService. Use `apiInitializationService.appConfig` instead of the SystemService methods.
+
+The System Service functionality is now handled directly by the ApiInitializationService during initialization. The service automatically fetches and caches shared configuration settings from the server's `/api/system/init` endpoint.
+
+#### Migration Guide
+
+**Old approach:**
+
+```ts
+import { systemService } from '@intellegens/cornerstone-client';
+
+// Initialize and fetch shared settings
+await systemService.initializeAsync();
+
+// Get cached settings
+const settings = systemService.getInitializationInfo();
 ```
 
+**New approach:**
+
+```ts
+import { apiInitializationService } from '@intellegens/cornerstone-client';
+
+// Initialize (automatically fetches shared settings)
+await apiInitializationService.initializeAsync();
+
+// Get cached settings
+const settings = apiInitializationService.appConfig;
+```
+
+#### Key Features
+
+- **Automatic Integration**: Settings are fetched during API initialization
+- **Type Safety**: Supports generic typed settings interfaces
+- **Error Handling**: Gracefully handles network errors and returns undefined for failed requests
+- **Server Integration**: Works seamlessly with Cornerstone server-side configuration system
+
 ### HTTP Service Abstraction
 
-The Cornerstone client provides a flexible HTTP service abstraction that allows you to use different HTTP libraries (Fetch API, Axios, Angular HttpClient) with the same API clients. This abstraction provides consistent behavior across different HTTP implementations while maintaining framework independence.
+The Cornerstone client provides a flexible HTTP service abstraction that allows you to use different HTTP libraries (Fetch API, Angular HttpClient) with the same API clients. This abstraction provides consistent behavior across different HTTP implementations while maintaining framework independence.
 
 #### Key Features
 
-- **Pluggable HTTP implementations** - Switch between Fetch, Axios, and Angular HttpClient
+- **Pluggable HTTP implementations** - Switch between Fetch and Angular HttpClient
 - **Consistent interface** - All HTTP services implement the same `IHttpService` interface
 - **Framework agnostic** - Use the same API clients in React, Angular, Vue, or any other framework
 - **Easy testing** - Mock HTTP requests easily for unit testing
@@ -85,14 +142,10 @@ The Cornerstone client provides a flexible HTTP service abstraction that allows
 #### Quick Example
 
 ```ts
-import { ApiReadControllerClient, FetchHttpService, AxiosHttpService } from '@intellegens/cornerstone-client';
+import { ApiReadControllerClient, FetchHttpService } from '@intellegens/cornerstone-client';
 
 // Using default Fetch implementation
 const client = new ApiReadControllerClient('/api/users');
-
-// Or specify a custom HTTP service
-const axiosService = new AxiosHttpService(axiosInstance);
-const clientWithAxios = new ApiReadControllerClient('/api/users', axiosService);
 ```
 
 For detailed documentation, examples, and advanced usage, see: [HTTP Service Documentation](./src/services/api/HttpService/README.md)
@@ -133,3 +186,71 @@ authService.logout(): Promise<UserDto | undefined>
 ```
 
 This method logs the user out by sending a request to the API to end the session. It returns undefined if the logout is successful
+
+### CollectionViewAdapter
+
+TS class for handling sorting, filtering and paginating collections
+
+Note that the collection is fetched on a page by page basis. Page size determines the number of items returned for display.
+
+```typescript
+ ngOnInit() {
+    this._adapter = new CollectionViewAdapter<number, ExampleDto>(
+      'Example', // controller name
+      (isLoading, data) => {
+        // data: ExampleDto[]
+        // handle as needed
+      },
+      this._options, // pass along initial options CollectionViewAdapterOptions<TDto>
+    );
+  }
+```
+
+### utils
+
+Helper functions for constructing `ReadSelectedSearchDefinitionDto`.
+
+Example usage:
+
+```typescript
+const search = condition(
+  ReadSelectedLogicalOperator.Or,
+  { path: 'clients', operator: ReadSelectedComparisonOperator.Contains, value: 'search-term', valueType: ReadSelectedPropertyType.String },
+  { path: 'suppliers', operator: ReadSelectedComparisonOperator.Contains, value: 'search-term', valueType: ReadSelectedPropertyType.String },
+  { path: 'facilities', operator: ReadSelectedComparisonOperator.Contains, value: 'search-term', valueType: ReadSelectedPropertyType.String },
+);
+
+const dateRange = condition(
+  ReadSelectedLogicalOperator.And,
+  {
+    path: 'createdDate',
+    operator: ReadSelectedComparisonOperator.GreaterOrEqual,
+    value: new Date('2024-01-01'),
+    valueType: ReadSelectedPropertyType.DateTime,
+  },
+  {
+    path: 'createdDate',
+    operator: ReadSelectedComparisonOperator.LessOrEqual,
+    value: new Date('2024-12-31'),
+    valueType: ReadSelectedPropertyType.DateTime,
+  },
+);
+
+const definition = and(search, dateRange);
+```
+
+Functions `searchTerm` and `dateInterval` have been prepared to simplify usage for these common needs:
+
+```typescript
+const definition = and(
+  searchTerm('search-term', textSearchablePaths, numericSearchablePaths),
+  dateInterval(
+    from,
+    to,
+    ReadSelectedComparisonOperator.GreaterOrEqual,
+    ReadSelectedComparisonOperator.LessOrEqual,
+    ReadSelectedPropertyType.DateTimeOffset,
+    'exampleColumnName',
+  ),
+);
+```

package/adapters/CollectionViewAdapter/index.d.ts

@@ -0,0 +1,154 @@
+import { IIdentifiable, ReadSelectedOrderingDirection, ReadSelectedSearchDefinitionDto } from '../../data';
+import { PropertyPathDto } from '../../data';
+/**
+ * Used with CollectionViewAdapter, a simplified configuration object for handling reading/writing from/to ReadSelectedDefinitionDto.
+ *
+ * @template TDto The type of the collection being sorted/filtered/paginated.
+ *
+ * @property {object} pagination - Pagination configuration
+ * @property {boolean} pagination.useTotalItemCount - Used for last page related logic of the paginator.
+ * Set to true if the total count for the collection is available; false assumes the last page is not known
+ * and adapts the pagination display accordingly.
+ * @property {number} [pagination.pageSize] - Number of items/rows to be fetched for the current page.
+ * @property {number} [pagination.pageNumber] - Current page index (skips fetching `(n-1) * pageSize` items/rows).
+ *
+ * @property {object} sorting - Sorting configuration
+ * @property {PropertyPathDto[]} [sorting.sortByPath] - Array of column/property names that are sortable.
+ * @property {ReadSelectedOrderingDirection} [sorting.sortDirection] - Enum for ascending/descending sort order.
+ *
+ * @property {object} searching - Search configuration
+ * @property {PropertyPathDto[]} [searching.textSearchablePaths] - Array of column/property names that are searchable where the value type is string.
+ * @property {PropertyPathDto[]} [searching.numericSearchablePaths] - Array of column/property names that are searchable where the value type is number.
+ * @property {ReadSelectedSearchDefinitionDto} [searching.searchDefinition] - The search definition by which the collection will be filtered.
+ */
+export type CollectionViewAdapterOptions = {
+    pagination: {
+        useTotalItemCount: boolean;
+        pageSize?: number;
+        pageNumber?: number;
+    };
+    sorting: {
+        sortByPath?: PropertyPathDto[];
+        sortDirection?: ReadSelectedOrderingDirection;
+    };
+    searching: {
+        textSearchablePaths?: PropertyPathDto[];
+        numericSearchablePaths?: PropertyPathDto[];
+        searchDefinition?: ReadSelectedSearchDefinitionDto;
+    };
+};
+/**
+ * TS class for handling sorting, filtering and paginating collections
+ *
+ * @param controllerName - specify the target endpoint controller name.
+ * @param dataChangedCallback - Function invoked whenever the data changes.
+ * Receives a loading state flag and the updated data collection.
+ * @param options - Optional settings of type `CollectionViewAdapterOptions<TDto>` to customize the behavior of the adapter.
+ */
+export declare class CollectionViewAdapter<TKey, TDto extends IIdentifiable<TKey>> {
+    private _readClient;
+    private _isLoading;
+    private _pageData;
+    private _defaultOptions;
+    private _initialOptions;
+    private _currentOptions;
+    constructor(controllerName: string, dataChangedCallback: (isLoading: boolean, data: TDto[] | undefined, error: string | undefined) => void, options?: CollectionViewAdapterOptions);
+    /**
+     * Allows for adding any filtering criteria. Label is required to distinguish custom search categories (e.g. searchTerm, dateRange, anyCustom ...)
+     */
+    setSearchDefinition(searchDefinition: ReadSelectedSearchDefinitionDto): Promise<TDto[]>;
+    /**
+     * Public method for sorting the collection by property path / column name.
+     *
+     * @param propertyPath - must match camel-cased property/column name being sorted
+     * @param sortDirection - use `ReadSelectedOrderingDirection` enum choices
+     */
+    setSorting(propertyPath: PropertyPathDto, sortDirection: ReadSelectedOrderingDirection): Promise<TDto[]>;
+    /**
+     * Returns the camel-cased property path of the current column/property on which sorting is applied, along with the `ReadSelectedOrderingDirection` direction
+     */
+    getCurrentSort(): {
+        sortByPath: PropertyPathDto | undefined;
+        sortDirection: ReadSelectedOrderingDirection | undefined;
+    };
+    /**
+     * Returns the current page's page number
+     */
+    get currentPage(): number | undefined;
+    /**
+     * Sets the current page to `pageNumber` and triggers data re-fetch
+     *
+     * @param pageNumber
+     */
+    jumpToPage(pageNumber: number): Promise<TDto[]>;
+    /**
+     * Returns the currently set page size value
+     */
+    get pageSize(): number | undefined;
+    /**
+     * Page size dictates the number of items or rows being fetched in a single API call
+     *
+     * @param pageSize
+     */
+    setPageSize(pageSize: number): Promise<TDto[]>;
+    private _totalItemCount;
+    /**
+     * Returns the total count value of the collection.
+     *
+     * If `CollectionViewAdapterOptions` has set `pagination.useTotalItemCount` to `true`, the API will return this value along with the collection and it will be set automatically.
+     * Else this adapter will attempt to dynamically calculate this value via `_calculateTotal()`.
+     */
+    get totalItemCount(): number;
+    /**
+     * Callback function invoked whenever data changes.
+     * Receives a loading state flag and the updated data collection.
+     */
+    private _dataChangedCallback;
+    /**
+     * Timeout reference used to debounce calls to `_fetchCurrentPageData`.
+     */
+    private _fetchCurrentPageDataTimeout?;
+    /**
+     * Queue of pending promises waiting for `_fetchCurrentPageData` to resolve or reject.
+     */
+    private _fetchCurrentPageDataPromises;
+    /**
+     * Tracks the current in-flight request controller to allow cancellation when a new fetch starts.
+     */
+    private _currentAbortController?;
+    /**
+     * Fetches the current page of data with debouncing support.
+     * Consolidates multiple concurrent calls into a single execution,
+     * resolving all queued promises with the same result.
+     *
+     * @returns A promise resolving to the fetched page of data.
+     */
+    private _fetchCurrentPageData;
+    /**
+     * Executes the actual data fetch operation after debounce delay.
+     * Updates the loading state, triggers data change callbacks,
+     * and handles total item count calculation if pagination is enabled.
+     *
+     * @returns A promise resolving to the fetched page of data.
+     */
+    private _fetchCurrentPageDataDebounced;
+    /**
+     * Takes current `CollectionViewAdapterOptions` and parses to `ReadSelectedDefinitionDto` which the cornerstone API expects.
+     *
+     * @returns - `ReadSelectedDefinitionDto` object
+     */
+    private _parseOptionsToDefinition;
+    /**
+     * Calculates the total item count given pagination inputs.
+     *
+     * For example, with 10 items per page, on page 2 with 3 items, total = 13.
+     * If the total cannot be inferred (e.g., a full page is returned), the previous total is returned unchanged.
+     *
+     * @param pageSize - Number of items per page
+     * @param currentPageNumber - Current page number (1-based)
+     * @param itemsOnCurrentPageCount - Number of items in the fetched page
+     * @param previousTotal - Previous known total to preserve when indeterminate
+     * @returns The computed total item count
+     */
+    private _calculateTotal;
+}

package/adapters/CollectionViewAdapter/index.js

@@ -0,0 +1,281 @@
+import { ReadSelectedOrderingDirection } from '../../data';
+import { toPascalCase } from '../../utils';
+import { ApiReadControllerClient } from '../../services';
+/**
+ * TS class for handling sorting, filtering and paginating collections
+ *
+ * @param controllerName - specify the target endpoint controller name.
+ * @param dataChangedCallback - Function invoked whenever the data changes.
+ * Receives a loading state flag and the updated data collection.
+ * @param options - Optional settings of type `CollectionViewAdapterOptions<TDto>` to customize the behavior of the adapter.
+ */
+export class CollectionViewAdapter {
+    _readClient;
+    _isLoading = false;
+    _pageData = [];
+    _defaultOptions = {
+        pagination: {
+            useTotalItemCount: false,
+            pageSize: 10,
+            pageNumber: 1,
+        },
+        sorting: {
+            sortByPath: [],
+            sortDirection: ReadSelectedOrderingDirection.Ascending,
+        },
+        searching: {
+            textSearchablePaths: [],
+            numericSearchablePaths: [],
+        },
+    };
+    _initialOptions;
+    _currentOptions;
+    constructor(controllerName, dataChangedCallback, options) {
+        this._readClient = new ApiReadControllerClient(controllerName);
+        this._initialOptions = {
+            pagination: {
+                ...this._defaultOptions.pagination,
+                ...options?.pagination,
+            },
+            sorting: {
+                ...this._defaultOptions.sorting,
+                ...options?.sorting,
+            },
+            searching: {
+                ...this._defaultOptions.searching,
+                ...options?.searching,
+            },
+        };
+        this._currentOptions = {
+            pagination: { ...this._initialOptions.pagination },
+            sorting: { ...this._initialOptions.sorting },
+            searching: { ...this._initialOptions.searching },
+        };
+        this._dataChangedCallback = dataChangedCallback;
+        this._fetchCurrentPageData();
+    }
+    //#region SEARCHING ------------------------------------------
+    /**
+     * Allows for adding any filtering criteria. Label is required to distinguish custom search categories (e.g. searchTerm, dateRange, anyCustom ...)
+     */
+    setSearchDefinition(searchDefinition) {
+        this._currentOptions.searching.searchDefinition = searchDefinition;
+        this._currentOptions.pagination.pageNumber = 1; // Reset to first page
+        return this._fetchCurrentPageData();
+    }
+    //#endregion -----------------------------------------------
+    //#region SORTING ------------------------------------------
+    /**
+     * Public method for sorting the collection by property path / column name.
+     *
+     * @param propertyPath - must match camel-cased property/column name being sorted
+     * @param sortDirection - use `ReadSelectedOrderingDirection` enum choices
+     */
+    setSorting(propertyPath, sortDirection) {
+        this._currentOptions.sorting.sortByPath = [propertyPath];
+        this._currentOptions.sorting.sortDirection = sortDirection;
+        this._currentOptions.pagination.pageNumber = 1; // Reset to first page
+        return this._fetchCurrentPageData();
+    }
+    /**
+     * Returns the camel-cased property path of the current column/property on which sorting is applied, along with the `ReadSelectedOrderingDirection` direction
+     */
+    getCurrentSort() {
+        return { sortByPath: this._currentOptions.sorting.sortByPath?.[0], sortDirection: this._currentOptions.sorting.sortDirection };
+    }
+    //#endregion -----------------------------------------------
+    //#region PAGINATION ---------------------------------------
+    /**
+     * Returns the current page's page number
+     */
+    get currentPage() {
+        return this._currentOptions.pagination.pageNumber;
+    }
+    /**
+     * Sets the current page to `pageNumber` and triggers data re-fetch
+     *
+     * @param pageNumber
+     */
+    jumpToPage(pageNumber) {
+        this._currentOptions.pagination.pageNumber = pageNumber;
+        return this._fetchCurrentPageData();
+    }
+    /**
+     * Returns the currently set page size value
+     */
+    get pageSize() {
+        return this._currentOptions.pagination.pageSize;
+    }
+    /**
+     * Page size dictates the number of items or rows being fetched in a single API call
+     *
+     * @param pageSize
+     */
+    setPageSize(pageSize) {
+        this._currentOptions.pagination.pageSize = pageSize;
+        this._currentOptions.pagination.pageNumber = 1; // Reset to first page
+        return this._fetchCurrentPageData();
+    }
+    _totalItemCount = -1;
+    /**
+     * Returns the total count value of the collection.
+     *
+     * If `CollectionViewAdapterOptions` has set `pagination.useTotalItemCount` to `true`, the API will return this value along with the collection and it will be set automatically.
+     * Else this adapter will attempt to dynamically calculate this value via `_calculateTotal()`.
+     */
+    get totalItemCount() {
+        return this._totalItemCount;
+    }
+    //#endregion -----------------------------------------------
+    /**
+     * Callback function invoked whenever data changes.
+     * Receives a loading state flag and the updated data collection.
+     */
+    _dataChangedCallback;
+    /**
+     * Timeout reference used to debounce calls to `_fetchCurrentPageData`.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _fetchCurrentPageDataTimeout;
+    /**
+     * Queue of pending promises waiting for `_fetchCurrentPageData` to resolve or reject.
+     */
+    _fetchCurrentPageDataPromises = [];
+    /**
+     * Tracks the current in-flight request controller to allow cancellation when a new fetch starts.
+     */
+    _currentAbortController;
+    /**
+     * Fetches the current page of data with debouncing support.
+     * Consolidates multiple concurrent calls into a single execution,
+     * resolving all queued promises with the same result.
+     *
+     * @returns A promise resolving to the fetched page of data.
+     */
+    async _fetchCurrentPageData() {
+        return new Promise((resolve, reject) => {
+            this._fetchCurrentPageDataPromises.push({ resolve, reject });
+            if (this._fetchCurrentPageDataTimeout !== undefined) {
+                clearTimeout(this._fetchCurrentPageDataTimeout);
+            }
+            this._fetchCurrentPageDataTimeout = setTimeout(async () => {
+                try {
+                    const result = await this._fetchCurrentPageDataDebounced();
+                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    for (const p of promises)
+                        p.resolve(result);
+                }
+                catch (err) {
+                    const promises = this._fetchCurrentPageDataPromises.splice(0, this._fetchCurrentPageDataPromises.length);
+                    for (const p of promises)
+                        p.reject(err);
+                }
+            }, 50);
+        });
+    }
+    /**
+     * Executes the actual data fetch operation after debounce delay.
+     * Updates the loading state, triggers data change callbacks,
+     * and handles total item count calculation if pagination is enabled.
+     *
+     * @returns A promise resolving to the fetched page of data.
+     */
+    async _fetchCurrentPageDataDebounced() {
+        this._isLoading = true;
+        this._dataChangedCallback(this._isLoading, undefined, undefined);
+        let abortController;
+        let caughtError;
+        try {
+            // Cancel any in-flight request before starting a new one
+            if (this._currentAbortController) {
+                try {
+                    this._currentAbortController.abort();
+                }
+                catch {
+                    // Ignore abort errors as they are expected when debouncing
+                }
+            }
+            abortController = new AbortController();
+            this._currentAbortController = abortController;
+            const definition = this._parseOptionsToDefinition();
+            const { result, metadata } = await this._readClient.readSelectedAsync(definition, abortController?.signal);
+            this._pageData = result;
+            if (this._currentOptions.pagination.useTotalItemCount && metadata.totalCount !== undefined) {
+                this._totalItemCount = metadata.totalCount;
+            }
+            else {
+                const pageSize = this._currentOptions.pagination.pageSize;
+                const currentPageNumber = this._currentOptions.pagination.pageNumber;
+                const itemsOnCurrentPageCount = this._pageData.length;
+                this._totalItemCount = this._calculateTotal(pageSize, currentPageNumber, itemsOnCurrentPageCount, this._totalItemCount);
+            }
+            return this._pageData;
+        }
+        catch (error) {
+            caughtError = error;
+            // Do not log abort-related errors as they are expected when debouncing
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return Promise.reject(error);
+            }
+            console.error('Error fetching data:', error);
+            return Promise.reject(error);
+        }
+        finally {
+            this._isLoading = false;
+            let errorName;
+            if (caughtError && !(caughtError instanceof DOMException && caughtError.name === 'AbortError')) {
+                errorName = caughtError instanceof Error ? caughtError.name : undefined;
+            }
+            this._dataChangedCallback(this._isLoading, this._pageData, errorName);
+            // Clear the abort controller only if it belongs to this request (avoid racing with a newer one)
+            if (abortController && this._currentAbortController === abortController) {
+                this._currentAbortController = undefined;
+            }
+        }
+    }
+    /**
+     * Takes current `CollectionViewAdapterOptions` and parses to `ReadSelectedDefinitionDto` which the cornerstone API expects.
+     *
+     * @returns - `ReadSelectedDefinitionDto` object
+     */
+    _parseOptionsToDefinition() {
+        const definition = {
+            paginationDefinition: {
+                skip: (this._currentOptions.pagination.pageNumber - 1) * this._currentOptions.pagination.pageSize,
+                limit: this._currentOptions.pagination.pageSize,
+            },
+        };
+        // Apply sorting
+        const sortPaths = this._currentOptions.sorting.sortByPath;
+        const sortDirection = this._currentOptions.sorting.sortDirection;
+        if (sortPaths && sortPaths.length > 0) {
+            definition.orderingDefinition = {
+                order: [{ propertyPath: sortPaths.map(path => toPascalCase(path)), direction: sortDirection ?? ReadSelectedOrderingDirection.Ascending }],
+            };
+        }
+        // Apply search
+        definition.searchDefinition = this._currentOptions.searching.searchDefinition;
+        return definition;
+    }
+    /**
+     * Calculates the total item count given pagination inputs.
+     *
+     * For example, with 10 items per page, on page 2 with 3 items, total = 13.
+     * If the total cannot be inferred (e.g., a full page is returned), the previous total is returned unchanged.
+     *
+     * @param pageSize - Number of items per page
+     * @param currentPageNumber - Current page number (1-based)
+     * @param itemsOnCurrentPageCount - Number of items in the fetched page
+     * @param previousTotal - Previous known total to preserve when indeterminate
+     * @returns The computed total item count
+     */
+    _calculateTotal(pageSize, currentPageNumber, itemsOnCurrentPageCount, previousTotal) {
+        if (itemsOnCurrentPageCount < pageSize && itemsOnCurrentPageCount !== 0) {
+            return pageSize * (currentPageNumber - 1) + itemsOnCurrentPageCount;
+        }
+        else if (itemsOnCurrentPageCount === 0 && pageSize === 0) {
+            return 0;
+        }
+        return previousTotal;
+    }
+}

package/adapters/index.d.ts

@@ -0,0 +1 @@
+export * from './CollectionViewAdapter';

package/adapters/index.js

@@ -0,0 +1 @@
+export * from './CollectionViewAdapter';

package/data/api/dto/PropertyPathDto.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Array of properties that when combined form a path to a property.
+ */
+export type PropertyPathDto = string[];

package/data/api/dto/ReadOptionsDto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Options for configuring read operations.
+ *
+ * @property {boolean} includeTotalCount - Whether to include the total count of items in the response.
+ */
+export type ReadOptionsDto = {
+    includeTotalCount: boolean;
+};

package/data/api/dto/ReadResultDto.d.ts

@@ -0,0 +1,12 @@
+import { ReadResultMetadataDto } from './ReadResultMetadataDto';
+/**
+ * Represents a read result containing a collection of results and metadata.
+ *
+ * @template T The type of result in the collection.
+ * @property {T[]} items - The collection of results returned.
+ * @property {ReadResultMetadata} metadata - Metadata about the paginated result.
+ */
+export type ReadResultDto<T> = {
+    results: T[];
+    metadata: ReadResultMetadataDto;
+};