@blueprint-ts/core 4.1.0-beta.2 → 4.1.0-beta.3

package/dist/pagination/PageAwarePaginator.js

@@ -0,0 +1,86 @@
+import { BasePaginator } from './BasePaginator';
+import { StaleResponseException } from '../requests/exceptions/StaleResponseException';
+export class PageAwarePaginator extends BasePaginator {
+    static setViewDriverFactory(value) {
+        PageAwarePaginator.viewDriverFactory = value;
+    }
+    constructor(dataDriver, pageNumber = 1, pageSize = 10, options) {
+        super(dataDriver);
+        this.dataDriver = dataDriver;
+        this.viewDriver = (options === null || options === void 0 ? void 0 : options.viewDriverFactory)
+            ? options.viewDriverFactory.make(pageNumber, pageSize)
+            : PageAwarePaginator.viewDriverFactory.make(pageNumber, pageSize);
+    }
+    setDataDriver(dataDriver) {
+        this.dataDriver = dataDriver;
+        return this;
+    }
+    getDataDriver() {
+        return this.dataDriver;
+    }
+    load(pageNumber, options) {
+        if (pageNumber !== undefined) {
+            this.setPageNumber(pageNumber);
+        }
+        return this.loadData(this.getCurrentPage(), this.getPageSize(), options);
+    }
+    setPageNumber(pageNumber) {
+        this.viewDriver.setPage(pageNumber);
+        return this;
+    }
+    getLastPage() {
+        return this.viewDriver.getLastPage();
+    }
+    toNextPage() {
+        this.setPageNumber(this.getCurrentPage() + 1);
+        return this.load();
+    }
+    toFirstPage() {
+        this.setPageNumber(1);
+        return this.load();
+    }
+    toLastPage() {
+        this.setPageNumber(this.viewDriver.getLastPage());
+        return this.load();
+    }
+    toPreviousPage() {
+        this.setPageNumber(this.getCurrentPage() - 1);
+        return this.load();
+    }
+    getCurrentPage() {
+        return this.viewDriver.getCurrentPage();
+    }
+    getFromItemNumber() {
+        return (this.getCurrentPage() - 1) * this.getPageSize() + 1;
+    }
+    getToItemNumber() {
+        return this.getCurrentPage() * this.getPageSize();
+    }
+    getPageSize() {
+        return this.viewDriver.getPageSize();
+    }
+    setPageSize(pageSize) {
+        this.viewDriver.setPageSize(pageSize);
+        if (this.getCurrentPage() * pageSize > this.getTotal()) {
+            this.setPageNumber(1);
+        }
+        return this;
+    }
+    getPages() {
+        return this.viewDriver.getPages();
+    }
+    loadData(pageNumber, pageSize, options) {
+        return this.dataDriver
+            .get(pageNumber, pageSize)
+            .then((value) => {
+            this.passDataToViewDriver(value, options);
+            return value;
+        })
+            .catch((error) => {
+            if (error instanceof StaleResponseException) {
+                return this.handleStaleResponse();
+            }
+            throw error;
+        });
+    }
+}

package/dist/pagination/StatePaginator.d.ts

@@ -0,0 +1,25 @@
+import { StatePaginationDataDto } from './dtos/StatePaginationDataDto';
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract';
+import { type BaseViewDriverFactoryContract } from './contracts/BaseViewDriverFactoryContract';
+import { type PaginatorLoadDataOptions } from './contracts/PaginatorLoadDataOptions';
+import { type StatePaginationDataDriverContract } from './contracts/StatePaginationDataDriverContract';
+import { BasePaginator } from './BasePaginator';
+export interface StatePaginatorOptions {
+    viewDriverFactory?: BaseViewDriverFactoryContract;
+}
+export declare class StatePaginator<ResourceInterface> extends BasePaginator<ResourceInterface, BaseViewDriverContract<ResourceInterface[]>> {
+    protected dataDriver: StatePaginationDataDriverContract<ResourceInterface[]>;
+    protected static viewDriverFactory: BaseViewDriverFactoryContract;
+    protected viewDriver: BaseViewDriverContract<ResourceInterface[]>;
+    protected currentState: string | null;
+    static setViewDriverFactory(value: BaseViewDriverFactoryContract): void;
+    constructor(dataDriver: StatePaginationDataDriverContract<ResourceInterface[]>, options?: StatePaginatorOptions);
+    setDataDriver(dataDriver: StatePaginationDataDriverContract<ResourceInterface[]>): this;
+    getDataDriver(): StatePaginationDataDriverContract<ResourceInterface[]>;
+    load(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>>;
+    loadNext(): Promise<StatePaginationDataDto<ResourceInterface[]>>;
+    hasNextPage(): boolean;
+    getCurrentState(): string | null;
+    protected loadData(options?: PaginatorLoadDataOptions): Promise<StatePaginationDataDto<ResourceInterface[]>>;
+    protected passStateDataToViewDriver(dto: StatePaginationDataDto<ResourceInterface[]>, options?: PaginatorLoadDataOptions): void;
+}

package/dist/pagination/StatePaginator.js

@@ -0,0 +1,55 @@
+import { BasePaginator } from './BasePaginator';
+export class StatePaginator extends BasePaginator {
+    static setViewDriverFactory(value) {
+        StatePaginator.viewDriverFactory = value;
+    }
+    constructor(dataDriver, options) {
+        super(dataDriver);
+        this.dataDriver = dataDriver;
+        this.currentState = null;
+        this.viewDriver = (options === null || options === void 0 ? void 0 : options.viewDriverFactory)
+            ? options.viewDriverFactory.make()
+            : StatePaginator.viewDriverFactory.make();
+    }
+    setDataDriver(dataDriver) {
+        this.dataDriver = dataDriver;
+        return this;
+    }
+    getDataDriver() {
+        return this.dataDriver;
+    }
+    load(options) {
+        this.currentState = null;
+        return this.loadData(Object.assign(Object.assign({}, options), { flush: true }));
+    }
+    loadNext() {
+        return this.loadData();
+    }
+    hasNextPage() {
+        return this.currentState !== null;
+    }
+    getCurrentState() {
+        return this.currentState;
+    }
+    loadData(options) {
+        return this.dataDriver.get(this.currentState).then((value) => {
+            this.currentState = value.getState();
+            this.passStateDataToViewDriver(value, options);
+            return value;
+        });
+    }
+    passStateDataToViewDriver(dto, options) {
+        const { flush = false, replace = false } = options || {};
+        if (flush) {
+            this.flush();
+        }
+        if (replace) {
+            this.viewDriver.setData(dto.getData());
+        }
+        else {
+            this.viewDriver.setData(this.viewDriver.getData().concat(dto.getData()));
+        }
+        this.viewDriver.setTotal(dto.getTotal());
+        this.initialized = true;
+    }
+}

package/dist/pagination/contracts/BaseViewDriverContract.d.ts

@@ -0,0 +1,6 @@
+export interface BaseViewDriverContract<ResourceInterface> {
+    setData(data: ResourceInterface): void;
+    getData(): ResourceInterface;
+    setTotal(value: number): void;
+    getTotal(): number;
+}

package/dist/pagination/contracts/BaseViewDriverContract.js

@@ -0,0 +1 @@
+export {};

package/{src/pagination/contracts/BaseViewDriverFactoryContract.ts → dist/pagination/contracts/BaseViewDriverFactoryContract.d.ts}

@@ -1,5 +1,4 @@
-import { type BaseViewDriverContract } from './BaseViewDriverContract'
-
+import { type BaseViewDriverContract } from './BaseViewDriverContract';
 export interface BaseViewDriverFactoryContract {
-  make<ResourceInterface>(): BaseViewDriverContract<ResourceInterface[]>
+    make<ResourceInterface>(): BaseViewDriverContract<ResourceInterface[]>;
 }

package/dist/pagination/contracts/BaseViewDriverFactoryContract.js

@@ -0,0 +1 @@
+export {};

package/dist/pagination/contracts/PaginateableRequestContract.d.ts

@@ -0,0 +1,4 @@
+import { type BaseRequestContract } from '../../requests/contracts/BaseRequestContract';
+export interface PaginateableRequestContract<RequestLoaderLoadingType, ResponseClass, RequestBodyInterface, RequestParamsInterface extends object> extends BaseRequestContract<RequestLoaderLoadingType, ResponseClass, RequestBodyInterface, RequestParamsInterface> {
+    setPaginationParams(page: number, size: number): BaseRequestContract<RequestLoaderLoadingType, ResponseClass, RequestBodyInterface, RequestParamsInterface>;
+}

package/dist/pagination/contracts/PaginateableRequestContract.js

@@ -0,0 +1 @@
+export {};

package/dist/pagination/contracts/PaginationDataDriverContract.d.ts

@@ -0,0 +1,4 @@
+import { PaginationDataDto } from '../dtos/PaginationDataDto';
+export interface PaginationDataDriverContract<ResourceInterface> {
+    get(pageNumber: number, pageSize: number): Promise<PaginationDataDto<ResourceInterface>>;
+}

package/dist/pagination/contracts/PaginationDataDriverContract.js

@@ -0,0 +1 @@
+export {};

package/{src/pagination/contracts/PaginationResponseContract.ts → dist/pagination/contracts/PaginationResponseContract.d.ts}

@@ -1,7 +1,5 @@
-import { type ResponseContract } from '../../requests/contracts/ResponseContract'
-
+import { type ResponseContract } from '../../requests/contracts/ResponseContract';
 export interface PaginationResponseContract<ResponseBodyInterface, ResourceInterface> extends ResponseContract<ResponseBodyInterface> {
-  getData(): ResourceInterface
-
-  getTotal(): number
+    getData(): ResourceInterface;
+    getTotal(): number;
 }

package/dist/pagination/contracts/PaginationResponseContract.js

@@ -0,0 +1 @@
+export {};

package/{src/pagination/contracts/PaginatorLoadDataOptions.ts → dist/pagination/contracts/PaginatorLoadDataOptions.d.ts}

@@ -1,4 +1,4 @@
 export interface PaginatorLoadDataOptions {
-  replace?: boolean
-  flush?: boolean
+    replace?: boolean;
+    flush?: boolean;
 }

package/dist/pagination/contracts/PaginatorLoadDataOptions.js

@@ -0,0 +1 @@
+export {};

package/{src/pagination/contracts/StatePaginationDataDriverContract.ts → dist/pagination/contracts/StatePaginationDataDriverContract.d.ts}

@@ -1,5 +1,4 @@
-import { StatePaginationDataDto } from '../dtos/StatePaginationDataDto'
-
+import { StatePaginationDataDto } from '../dtos/StatePaginationDataDto';
 export interface StatePaginationDataDriverContract<ResourceInterface> {
-  get(state?: string | null): Promise<StatePaginationDataDto<ResourceInterface>>
+    get(state?: string | null): Promise<StatePaginationDataDto<ResourceInterface>>;
 }

package/dist/pagination/contracts/StatePaginationDataDriverContract.js

@@ -0,0 +1 @@
+export {};

package/dist/pagination/contracts/ViewDriverContract.d.ts

@@ -0,0 +1,9 @@
+import { type BaseViewDriverContract } from './BaseViewDriverContract';
+export interface ViewDriverContract<ResourceInterface> extends BaseViewDriverContract<ResourceInterface> {
+    getCurrentPage(): number;
+    setPage(value: number): void;
+    setPageSize(value: number): void;
+    getPageSize(): number;
+    getLastPage(): number;
+    getPages(): number[];
+}

package/dist/pagination/contracts/ViewDriverContract.js

@@ -0,0 +1 @@
+export {};

package/dist/pagination/contracts/ViewDriverFactoryContract.d.ts

@@ -0,0 +1,4 @@
+import { type ViewDriverContract } from './ViewDriverContract';
+export interface ViewDriverFactoryContract {
+    make<ResourceInterface>(page: number, size: number): ViewDriverContract<ResourceInterface[]>;
+}

package/dist/pagination/contracts/ViewDriverFactoryContract.js

@@ -0,0 +1 @@
+export {};

package/dist/pagination/dataDrivers/ArrayDriver.d.ts

@@ -0,0 +1,9 @@
+import { type PaginationDataDriverContract, PaginationDataDto } from '../index';
+export declare class ArrayDriver<ResourceInterface> implements PaginationDataDriverContract<ResourceInterface[]> {
+    protected data: ResourceInterface[];
+    constructor(data: ResourceInterface[]);
+    get(page: number, size: number): Promise<PaginationDataDto<ResourceInterface[]>>;
+    setData(data: ResourceInterface[]): void;
+    protected calculatedStart(currentPage: number, pageSize: number): number;
+    protected calculatedEnd(currentPage: number, pageSize: number): number;
+}

package/dist/pagination/dataDrivers/ArrayDriver.js

@@ -0,0 +1,20 @@
+import { PaginationDataDto } from '../index';
+export class ArrayDriver {
+    constructor(data) {
+        this.data = data;
+    }
+    get(page, size) {
+        return new Promise((resolve) => {
+            resolve(new PaginationDataDto(this.data.slice(this.calculatedStart(page, size), this.calculatedEnd(page, size)), this.data.length));
+        });
+    }
+    setData(data) {
+        this.data = data;
+    }
+    calculatedStart(currentPage, pageSize) {
+        return (currentPage - 1) * pageSize;
+    }
+    calculatedEnd(currentPage, pageSize) {
+        return currentPage * pageSize;
+    }
+}

package/dist/pagination/dtos/PaginationDataDto.d.ts

@@ -0,0 +1,7 @@
+export declare class PaginationDataDto<ResourceInterface> {
+    protected data: ResourceInterface;
+    protected total: number;
+    constructor(data: ResourceInterface, total: number);
+    getData(): ResourceInterface;
+    getTotal(): number;
+}

package/dist/pagination/dtos/PaginationDataDto.js

@@ -0,0 +1,12 @@
+export class PaginationDataDto {
+    constructor(data, total) {
+        this.data = data;
+        this.total = total;
+    }
+    getData() {
+        return this.data;
+    }
+    getTotal() {
+        return this.total;
+    }
+}

package/dist/pagination/dtos/StatePaginationDataDto.d.ts

@@ -0,0 +1,7 @@
+import { PaginationDataDto } from './PaginationDataDto';
+export declare class StatePaginationDataDto<ResourceInterface> extends PaginationDataDto<ResourceInterface> {
+    protected state: string | null;
+    constructor(data: ResourceInterface, total: number, state?: string | null);
+    getState(): string | null;
+    hasNextPage(): boolean;
+}

package/dist/pagination/dtos/StatePaginationDataDto.js

@@ -0,0 +1,13 @@
+import { PaginationDataDto } from './PaginationDataDto';
+export class StatePaginationDataDto extends PaginationDataDto {
+    constructor(data, total, state = null) {
+        super(data, total);
+        this.state = state;
+    }
+    getState() {
+        return this.state;
+    }
+    hasNextPage() {
+        return this.state !== null;
+    }
+}

package/dist/pagination/factories/VueBaseViewDriverFactory.d.ts

@@ -0,0 +1,5 @@
+import { type BaseViewDriverFactoryContract } from '../contracts/BaseViewDriverFactoryContract';
+import { type BaseViewDriverContract } from '../contracts/BaseViewDriverContract';
+export declare class VueBaseViewDriverFactory implements BaseViewDriverFactoryContract {
+    make<ResourceInterface>(): BaseViewDriverContract<ResourceInterface[]>;
+}

package/dist/pagination/factories/VueBaseViewDriverFactory.js

@@ -0,0 +1,6 @@
+import { VueBaseViewDriver } from '../frontendDrivers/VueBaseViewDriver';
+export class VueBaseViewDriverFactory {
+    make() {
+        return new VueBaseViewDriver();
+    }
+}

package/dist/pagination/factories/VuePaginationDriverFactory.d.ts

@@ -0,0 +1,5 @@
+import { type ViewDriverFactoryContract } from '../contracts/ViewDriverFactoryContract';
+import { type ViewDriverContract } from '../contracts/ViewDriverContract';
+export declare class VuePaginationDriverFactory implements ViewDriverFactoryContract {
+    make<ResourceInterface>(pageNumber: number, pageSize: number): ViewDriverContract<ResourceInterface[]>;
+}

package/dist/pagination/factories/VuePaginationDriverFactory.js

@@ -0,0 +1,6 @@
+import { VuePaginationDriver } from '../frontendDrivers/VuePaginationDriver';
+export class VuePaginationDriverFactory {
+    make(pageNumber, pageSize) {
+        return new VuePaginationDriver(pageNumber, pageSize);
+    }
+}

package/dist/pagination/frontendDrivers/VueBaseViewDriver.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from 'vue';
+import { type BaseViewDriverContract } from '../contracts/BaseViewDriverContract';
+export declare class VueBaseViewDriver<ResourceInterface> implements BaseViewDriverContract<ResourceInterface[]> {
+    protected dataRef: Ref<ResourceInterface[]>;
+    protected totalRef: Ref<number>;
+    constructor();
+    setData(data: ResourceInterface[]): void;
+    getData(): ResourceInterface[];
+    setTotal(value: number): void;
+    getTotal(): number;
+}

package/dist/pagination/frontendDrivers/VueBaseViewDriver.js

@@ -0,0 +1,19 @@
+import { ref } from 'vue';
+export class VueBaseViewDriver {
+    constructor() {
+        this.dataRef = ref([]);
+        this.totalRef = ref(0);
+    }
+    setData(data) {
+        this.dataRef.value = data;
+    }
+    getData() {
+        return this.dataRef.value;
+    }
+    setTotal(value) {
+        this.totalRef.value = value;
+    }
+    getTotal() {
+        return this.totalRef.value;
+    }
+}

package/dist/pagination/frontendDrivers/VuePaginationDriver.d.ts

@@ -0,0 +1,21 @@
+import { type Ref, type ComputedRef } from 'vue';
+import { type ViewDriverContract } from '../contracts/ViewDriverContract';
+export declare class VuePaginationDriver<ResourceInterface> implements ViewDriverContract<ResourceInterface[]> {
+    protected dataRef: Ref<ResourceInterface[]>;
+    protected currentPageRef: Ref<number>;
+    protected pageSizeRef: Ref<number>;
+    protected totalRef: Ref<number>;
+    protected totalPagesComputed: ComputedRef<number>;
+    protected pagesComputed: ComputedRef<number[]>;
+    constructor(pageNumber: number, pageSize: number);
+    setData(data: ResourceInterface[]): void;
+    setTotal(value: number): void;
+    getData(): ResourceInterface[];
+    getCurrentPage(): number;
+    setPage(value: number): void;
+    setPageSize(value: number): void;
+    getPageSize(): number;
+    getLastPage(): number;
+    getPages(): number[];
+    getTotal(): number;
+}

package/dist/pagination/frontendDrivers/VuePaginationDriver.js

@@ -0,0 +1,41 @@
+import { computed, ref } from 'vue';
+export class VuePaginationDriver {
+    constructor(pageNumber, pageSize) {
+        this.dataRef = ref([]);
+        this.currentPageRef = ref(pageNumber);
+        this.pageSizeRef = ref(pageSize);
+        this.totalRef = ref(0);
+        this.totalPagesComputed = computed(() => Math.ceil(this.totalRef.value / this.pageSizeRef.value));
+        this.pagesComputed = computed(() => Array.from({ length: this.totalPagesComputed.value }, (_, i) => i + 1));
+    }
+    setData(data) {
+        this.dataRef.value = data;
+    }
+    setTotal(value) {
+        this.totalRef.value = value;
+    }
+    getData() {
+        return this.dataRef.value;
+    }
+    getCurrentPage() {
+        return this.currentPageRef.value;
+    }
+    setPage(value) {
+        this.currentPageRef.value = value;
+    }
+    setPageSize(value) {
+        this.pageSizeRef.value = value;
+    }
+    getPageSize() {
+        return this.pageSizeRef.value;
+    }
+    getLastPage() {
+        return this.totalPagesComputed.value;
+    }
+    getPages() {
+        return this.pagesComputed.value;
+    }
+    getTotal() {
+        return this.totalRef.value;
+    }
+}

package/dist/pagination/index.d.ts

@@ -0,0 +1,22 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+import { StatePaginationDataDto } from './dtos/StatePaginationDataDto';
+import { VuePaginationDriver } from './frontendDrivers/VuePaginationDriver';
+import { VueBaseViewDriver } from './frontendDrivers/VueBaseViewDriver';
+import { BasePaginator } from './BasePaginator';
+import { PageAwarePaginator } from './PageAwarePaginator';
+import { StatePaginator } from './StatePaginator';
+import { InfiniteScroller } from './InfiniteScroller';
+import { VuePaginationDriverFactory } from './factories/VuePaginationDriverFactory';
+import { VueBaseViewDriverFactory } from './factories/VueBaseViewDriverFactory';
+import { type PaginateableRequestContract } from './contracts/PaginateableRequestContract';
+import { type PaginationResponseContract } from './contracts/PaginationResponseContract';
+import { type PaginationDataDriverContract } from './contracts/PaginationDataDriverContract';
+import { type StatePaginationDataDriverContract } from './contracts/StatePaginationDataDriverContract';
+import { getDisplayablePages } from '../support/helpers';
+import { ArrayDriver } from './dataDrivers/ArrayDriver';
+import { type BaseViewDriverContract } from './contracts/BaseViewDriverContract';
+import { type ViewDriverContract } from './contracts/ViewDriverContract';
+import { type BaseViewDriverFactoryContract } from './contracts/BaseViewDriverFactoryContract';
+import { type ViewDriverFactoryContract } from './contracts/ViewDriverFactoryContract';
+export { PaginationDataDto, StatePaginationDataDto, VuePaginationDriver, VueBaseViewDriver, BasePaginator, PageAwarePaginator, StatePaginator, InfiniteScroller, VuePaginationDriverFactory, VueBaseViewDriverFactory, getDisplayablePages, ArrayDriver };
+export type { PaginationDataDriverContract, StatePaginationDataDriverContract, PaginationResponseContract, PaginateableRequestContract, BaseViewDriverContract, ViewDriverContract, BaseViewDriverFactoryContract, ViewDriverFactoryContract };

package/dist/pagination/index.js

@@ -0,0 +1,13 @@
+import { PaginationDataDto } from './dtos/PaginationDataDto';
+import { StatePaginationDataDto } from './dtos/StatePaginationDataDto';
+import { VuePaginationDriver } from './frontendDrivers/VuePaginationDriver';
+import { VueBaseViewDriver } from './frontendDrivers/VueBaseViewDriver';
+import { BasePaginator } from './BasePaginator';
+import { PageAwarePaginator } from './PageAwarePaginator';
+import { StatePaginator } from './StatePaginator';
+import { InfiniteScroller } from './InfiniteScroller';
+import { VuePaginationDriverFactory } from './factories/VuePaginationDriverFactory';
+import { VueBaseViewDriverFactory } from './factories/VueBaseViewDriverFactory';
+import { getDisplayablePages } from '../support/helpers';
+import { ArrayDriver } from './dataDrivers/ArrayDriver';
+export { PaginationDataDto, StatePaginationDataDto, VuePaginationDriver, VueBaseViewDriver, BasePaginator, PageAwarePaginator, StatePaginator, InfiniteScroller, VuePaginationDriverFactory, VueBaseViewDriverFactory, getDisplayablePages, ArrayDriver };

package/dist/persistenceDrivers/LocalStorageDriver.d.ts

@@ -0,0 +1,9 @@
+import { type PersistenceDriver } from './types/PersistenceDriver';
+export declare class LocalStorageDriver implements PersistenceDriver {
+    protected suffix?: string | undefined;
+    constructor(suffix?: string | undefined);
+    private storageKey;
+    get<T>(key: string): T | null;
+    set<T>(key: string, state: T): void;
+    remove(key: string): void;
+}

package/dist/persistenceDrivers/LocalStorageDriver.js

@@ -0,0 +1,18 @@
+export class LocalStorageDriver {
+    constructor(suffix) {
+        this.suffix = suffix;
+    }
+    storageKey(key) {
+        return this.suffix ? `state_${key}_${this.suffix}` : `state_${key}`;
+    }
+    get(key) {
+        const data = localStorage.getItem(this.storageKey(key));
+        return data ? JSON.parse(data) : null;
+    }
+    set(key, state) {
+        localStorage.setItem(this.storageKey(key), JSON.stringify(state));
+    }
+    remove(key) {
+        localStorage.removeItem(this.storageKey(key));
+    }
+}

package/dist/persistenceDrivers/NonPersistentDriver.d.ts

@@ -0,0 +1,7 @@
+import { type PersistenceDriver } from './types/PersistenceDriver';
+/** Default driver: does not persist any data. */
+export declare class NonPersistentDriver implements PersistenceDriver {
+    get(): null;
+    set(): void;
+    remove(): void;
+}

package/dist/persistenceDrivers/NonPersistentDriver.js

@@ -0,0 +1,8 @@
+/** Default driver: does not persist any data. */
+export class NonPersistentDriver {
+    get() {
+        return null;
+    }
+    set() { }
+    remove() { }
+}

package/dist/persistenceDrivers/SessionStorageDriver.d.ts

@@ -0,0 +1,9 @@
+import { type PersistenceDriver } from './types/PersistenceDriver';
+export declare class SessionStorageDriver implements PersistenceDriver {
+    protected suffix?: string | undefined;
+    constructor(suffix?: string | undefined);
+    private storageKey;
+    get<T>(key: string): T | null;
+    set<T>(key: string, state: T): void;
+    remove(key: string): void;
+}

package/dist/persistenceDrivers/SessionStorageDriver.js

@@ -0,0 +1,18 @@
+export class SessionStorageDriver {
+    constructor(suffix) {
+        this.suffix = suffix;
+    }
+    storageKey(key) {
+        return this.suffix ? `state_${key}_${this.suffix}` : `state_${key}`;
+    }
+    get(key) {
+        const data = sessionStorage.getItem(this.storageKey(key));
+        return data ? JSON.parse(data) : null;
+    }
+    set(key, state) {
+        sessionStorage.setItem(this.storageKey(key), JSON.stringify(state));
+    }
+    remove(key) {
+        sessionStorage.removeItem(this.storageKey(key));
+    }
+}

package/dist/persistenceDrivers/index.d.ts

@@ -0,0 +1,6 @@
+import { LocalStorageDriver } from './LocalStorageDriver';
+import { NonPersistentDriver } from './NonPersistentDriver';
+import { SessionStorageDriver } from './SessionStorageDriver';
+import { type PersistenceDriver } from './types/PersistenceDriver';
+export { LocalStorageDriver, NonPersistentDriver, SessionStorageDriver };
+export type { PersistenceDriver };

package/dist/persistenceDrivers/index.js

@@ -0,0 +1,4 @@
+import { LocalStorageDriver } from './LocalStorageDriver';
+import { NonPersistentDriver } from './NonPersistentDriver';
+import { SessionStorageDriver } from './SessionStorageDriver';
+export { LocalStorageDriver, NonPersistentDriver, SessionStorageDriver };

package/dist/persistenceDrivers/types/PersistenceDriver.d.ts

@@ -0,0 +1,5 @@
+export interface PersistenceDriver {
+    get<T>(key: string): T | null;
+    set<T>(key: string, state: T): void;
+    remove(key: string): void;
+}

package/dist/persistenceDrivers/types/PersistenceDriver.js

@@ -0,0 +1 @@
+export {};