@webiny/app-utils 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

package/README.md

@@ -1,18 +1,11 @@
 # @webiny/app-utils
 
-[![](https://img.shields.io/npm/dw/@webiny/app-utils.svg)](https://www.npmjs.com/package/@webiny/app-utils)
-[![](https://img.shields.io/npm/v/@webiny/app-utils.svg)](https://www.npmjs.com/package/@webiny/app-utils)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
 
-## Install
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
 
-```
-npm install --save @webiny/app-utils
-```
+---
 
-Or if you prefer yarn:
-
-```
-yarn add @webiny/app-utils
-```
+_This README file is automatically generated during the publish process._

package/features/List/FilterFeature.d.ts

@@ -0,0 +1,11 @@
+import { type IFilterFeature, ListQueryParamsRepository, type BaseListParams } from "./abstractions.js";
+declare class FilterFeatureImpl<TParams extends BaseListParams> implements IFilterFeature {
+    private queryParams;
+    constructor(queryParams: ListQueryParamsRepository.Interface<TParams>);
+    setFilter(key: string, value: unknown): Promise<void>;
+    clearAllFilters(): Promise<void>;
+}
+export declare const FilterFeature: typeof FilterFeatureImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IFilterFeature>;
+};
+export {};

package/features/List/FilterFeature.js

@@ -0,0 +1,26 @@
+import { FilterFeature, ListQueryParamsRepository } from "./abstractions.js";
+class FilterFeatureImpl {
+    constructor(queryParams){
+        this.queryParams = queryParams;
+    }
+    async setFilter(key, value) {
+        await this.queryParams.set((params)=>{
+            if (!params.filters) params.filters = {};
+            params.filters[key] = value;
+        });
+    }
+    async clearAllFilters() {
+        await this.queryParams.set((params)=>{
+            params.filters = {};
+        });
+    }
+}
+const FilterFeature_FilterFeature = FilterFeature.createImplementation({
+    implementation: FilterFeatureImpl,
+    dependencies: [
+        ListQueryParamsRepository
+    ]
+});
+export { FilterFeature_FilterFeature as FilterFeature };
+
+//# sourceMappingURL=FilterFeature.js.map

package/features/List/FilterFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/FilterFeature.js","sources":["../../../src/features/List/FilterFeature.ts"],"sourcesContent":["import {\n    FilterFeature as Abstraction,\n    type IFilterFeature,\n    ListQueryParamsRepository,\n    type BaseListParams\n} from \"./abstractions.js\";\n\nclass FilterFeatureImpl<TParams extends BaseListParams> implements IFilterFeature {\n    constructor(private queryParams: ListQueryParamsRepository.Interface<TParams>) {}\n\n    async setFilter(key: string, value: unknown): Promise<void> {\n        await this.queryParams.set(params => {\n            if (!params.filters) {\n                params.filters = {};\n            }\n            params.filters[key] = value;\n        });\n    }\n\n    async clearAllFilters(): Promise<void> {\n        await this.queryParams.set(params => {\n            params.filters = {};\n        });\n    }\n}\n\nexport const FilterFeature = Abstraction.createImplementation({\n    implementation: FilterFeatureImpl,\n    dependencies: [ListQueryParamsRepository]\n});\n"],"names":["FilterFeatureImpl","queryParams","key","value","params","FilterFeature","Abstraction","ListQueryParamsRepository"],"mappings":";AAOA,MAAMA;IACF,YAAoBC,WAAyD,CAAE;aAA3DA,WAAW,GAAXA;IAA4D;IAEhF,MAAM,UAAUC,GAAW,EAAEC,KAAc,EAAiB;QACxD,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,CAAAA;YACvB,IAAI,CAACA,OAAO,OAAO,EACfA,OAAO,OAAO,GAAG,CAAC;YAEtBA,OAAO,OAAO,CAACF,IAAI,GAAGC;QAC1B;IACJ;IAEA,MAAM,kBAAiC;QACnC,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,CAAAA;YACvBA,OAAO,OAAO,GAAG,CAAC;QACtB;IACJ;AACJ;AAEO,MAAMC,8BAAgBC,cAAAA,oBAAgC,CAAC;IAC1D,gBAAgBN;IAChB,cAAc;QAACO;KAA0B;AAC7C"}

package/features/List/ListQueryParamsRepository.d.ts

@@ -0,0 +1,18 @@
+import { type BaseListParams, type IListQueryParamsRepository } from "./abstractions.js";
+export declare class ListQueryParamsRepositoryImpl<TParams extends BaseListParams> implements IListQueryParamsRepository<TParams> {
+    private params;
+    private readonly initial;
+    private readonly listeners;
+    constructor();
+    get(): TParams;
+    set(updater: (params: TParams) => void): Promise<void>;
+    replace(next: TParams): Promise<void>;
+    reset(): void;
+    subscribe(listener: (next: TParams) => void): () => void;
+    dispose(): void;
+    private notify;
+    private clone;
+}
+export declare const ListQueryParamsRepository: typeof ListQueryParamsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IListQueryParamsRepository<any>>;
+};

package/features/List/ListQueryParamsRepository.js

@@ -0,0 +1,68 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { ListQueryParamsRepository } from "./abstractions.js";
+class ListQueryParamsRepositoryImpl {
+    constructor(){
+        this.listeners = new Set();
+        this.initial = {
+            search: "",
+            sort: [],
+            filters: {},
+            limit: 50
+        };
+        this.params = this.clone(this.initial);
+        makeAutoObservable(this, {
+            subscribe: false,
+            dispose: false
+        }, {
+            autoBind: true
+        });
+    }
+    get() {
+        return this.clone(this.params);
+    }
+    async set(updater) {
+        runInAction(()=>{
+            updater(this.params);
+        });
+        this.notify();
+    }
+    async replace(next) {
+        runInAction(()=>{
+            this.params = this.clone(next);
+        });
+        this.notify();
+    }
+    reset() {
+        runInAction(()=>{
+            this.params = this.clone(this.initial);
+        });
+        this.notify();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return ()=>{
+            this.listeners.delete(listener);
+        };
+    }
+    dispose() {
+        this.listeners.clear();
+    }
+    notify() {
+        const snap = this.clone(this.params);
+        for (const listener of this.listeners)try {
+            listener(snap);
+        } catch (error) {
+            console.error("Error in ListQueryParams listener:", error);
+        }
+    }
+    clone(value) {
+        return structuredClone ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+    }
+}
+const ListQueryParamsRepository_ListQueryParamsRepository = ListQueryParamsRepository.createImplementation({
+    implementation: ListQueryParamsRepositoryImpl,
+    dependencies: []
+});
+export { ListQueryParamsRepositoryImpl, ListQueryParamsRepository_ListQueryParamsRepository as ListQueryParamsRepository };
+
+//# sourceMappingURL=ListQueryParamsRepository.js.map

package/features/List/ListQueryParamsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/ListQueryParamsRepository.js","sources":["../../../src/features/List/ListQueryParamsRepository.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport {\n    ListQueryParamsRepository as Abstraction,\n    type BaseListParams,\n    type IListQueryParamsRepository\n} from \"./abstractions.js\";\n\nexport class ListQueryParamsRepositoryImpl<\n    TParams extends BaseListParams\n> implements IListQueryParamsRepository<TParams> {\n    private params: TParams;\n    private readonly initial: TParams;\n    private readonly listeners = new Set<(next: TParams) => void>();\n\n    constructor() {\n        this.initial = { search: \"\", sort: [], filters: {}, limit: 50 } as unknown as TParams;\n        this.params = this.clone(this.initial) as unknown as TParams;\n\n        makeAutoObservable(\n            this,\n            {\n                subscribe: false,\n                dispose: false\n            },\n            { autoBind: true }\n        );\n    }\n\n    get(): TParams {\n        return this.clone(this.params);\n    }\n\n    async set(updater: (params: TParams) => void): Promise<void> {\n        runInAction(() => {\n            updater(this.params);\n        });\n        this.notify();\n    }\n\n    async replace(next: TParams): Promise<void> {\n        runInAction(() => {\n            this.params = this.clone(next);\n        });\n        this.notify();\n    }\n\n    reset(): void {\n        runInAction(() => {\n            this.params = this.clone(this.initial);\n        });\n        this.notify();\n    }\n\n    subscribe(listener: (next: TParams) => void): () => void {\n        this.listeners.add(listener);\n        return () => {\n            this.listeners.delete(listener);\n        };\n    }\n\n    dispose(): void {\n        this.listeners.clear();\n    }\n\n    private notify(): void {\n        const snap = this.clone(this.params);\n        for (const listener of this.listeners) {\n            try {\n                listener(snap);\n            } catch (error) {\n                // Swallow listener errors to prevent cascading failures\n                console.error(\"Error in ListQueryParams listener:\", error);\n            }\n        }\n    }\n\n    private clone(value: TParams): TParams {\n        return structuredClone ? structuredClone(value) : JSON.parse(JSON.stringify(value));\n    }\n}\n\nexport const ListQueryParamsRepository = Abstraction.createImplementation({\n    implementation: ListQueryParamsRepositoryImpl,\n    dependencies: []\n});\n"],"names":["ListQueryParamsRepositoryImpl","Set","makeAutoObservable","updater","runInAction","next","listener","snap","error","console","value","structuredClone","JSON","ListQueryParamsRepository","Abstraction"],"mappings":";;AAOO,MAAMA;IAOT,aAAc;aAFG,SAAS,GAAG,IAAIC;QAG7B,IAAI,CAAC,OAAO,GAAG;YAAE,QAAQ;YAAI,MAAM,EAAE;YAAE,SAAS,CAAC;YAAG,OAAO;QAAG;QAC9D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO;QAErCC,mBACI,IAAI,EACJ;YACI,WAAW;YACX,SAAS;QACb,GACA;YAAE,UAAU;QAAK;IAEzB;IAEA,MAAe;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM;IACjC;IAEA,MAAM,IAAIC,OAAkC,EAAiB;QACzDC,YAAY;YACRD,QAAQ,IAAI,CAAC,MAAM;QACvB;QACA,IAAI,CAAC,MAAM;IACf;IAEA,MAAM,QAAQE,IAAa,EAAiB;QACxCD,YAAY;YACR,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAACC;QAC7B;QACA,IAAI,CAAC,MAAM;IACf;IAEA,QAAc;QACVD,YAAY;YACR,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO;QACzC;QACA,IAAI,CAAC,MAAM;IACf;IAEA,UAAUE,QAAiC,EAAc;QACrD,IAAI,CAAC,SAAS,CAAC,GAAG,CAACA;QACnB,OAAO;YACH,IAAI,CAAC,SAAS,CAAC,MAAM,CAACA;QAC1B;IACJ;IAEA,UAAgB;QACZ,IAAI,CAAC,SAAS,CAAC,KAAK;IACxB;IAEQ,SAAe;QACnB,MAAMC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM;QACnC,KAAK,MAAMD,YAAY,IAAI,CAAC,SAAS,CACjC,IAAI;YACAA,SAASC;QACb,EAAE,OAAOC,OAAO;YAEZC,QAAQ,KAAK,CAAC,sCAAsCD;QACxD;IAER;IAEQ,MAAME,KAAc,EAAW;QACnC,OAAOC,kBAAkBA,gBAAgBD,SAASE,KAAK,KAAK,CAACA,KAAK,SAAS,CAACF;IAChF;AACJ;AAEO,MAAMG,sDAA4BC,0BAAAA,oBAAgC,CAAC;IACtE,gBAAgBd;IAChB,cAAc,EAAE;AACpB"}

package/features/List/LoadMoreFeature.d.ts

@@ -0,0 +1,13 @@
+import { type ILoadMoreFeature, ListDataRepository, ListQueryParamsRepository, LoadingRepository, type BaseListParams } from "./abstractions.js";
+declare class LoadMoreFeatureImpl<TItem, TParams extends BaseListParams> implements ILoadMoreFeature {
+    private repository;
+    private queryParams;
+    private loading;
+    constructor(repository: ListDataRepository.Interface<TItem, TParams>, queryParams: ListQueryParamsRepository.Interface<TParams>, loading: LoadingRepository.Interface);
+    execute(): Promise<void>;
+    private canLoadMore;
+}
+export declare const LoadMoreFeature: typeof LoadMoreFeatureImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ILoadMoreFeature>;
+};
+export {};

package/features/List/LoadMoreFeature.js

@@ -0,0 +1,28 @@
+import { ListDataRepository, ListQueryParamsRepository, LoadMoreFeature, LoadingRepository } from "./abstractions.js";
+class LoadMoreFeatureImpl {
+    constructor(repository, queryParams, loading){
+        this.repository = repository;
+        this.queryParams = queryParams;
+        this.loading = loading;
+    }
+    async execute() {
+        if (!this.canLoadMore()) return;
+        const params = this.queryParams.get();
+        await this.loading.runCallback(this.repository.append(params), "loadMore");
+    }
+    canLoadMore() {
+        if (this.loading.isLoading("loadMore")) return false;
+        return this.repository.hasMore();
+    }
+}
+const LoadMoreFeature_LoadMoreFeature = LoadMoreFeature.createImplementation({
+    implementation: LoadMoreFeatureImpl,
+    dependencies: [
+        ListDataRepository,
+        ListQueryParamsRepository,
+        LoadingRepository
+    ]
+});
+export { LoadMoreFeature_LoadMoreFeature as LoadMoreFeature };
+
+//# sourceMappingURL=LoadMoreFeature.js.map

package/features/List/LoadMoreFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/LoadMoreFeature.js","sources":["../../../src/features/List/LoadMoreFeature.ts"],"sourcesContent":["import {\n    LoadMoreFeature as Abstraction,\n    type ILoadMoreFeature,\n    ListDataRepository,\n    ListQueryParamsRepository,\n    LoadingRepository,\n    type BaseListParams\n} from \"./abstractions.js\";\n\nclass LoadMoreFeatureImpl<TItem, TParams extends BaseListParams> implements ILoadMoreFeature {\n    constructor(\n        private repository: ListDataRepository.Interface<TItem, TParams>,\n        private queryParams: ListQueryParamsRepository.Interface<TParams>,\n        private loading: LoadingRepository.Interface\n    ) {}\n\n    async execute(): Promise<void> {\n        if (!this.canLoadMore()) {\n            return;\n        }\n\n        const params = this.queryParams.get();\n\n        await this.loading.runCallback(this.repository.append(params), \"loadMore\");\n    }\n\n    private canLoadMore(): boolean {\n        // Don't allow load more if already loading\n        if (this.loading.isLoading(\"loadMore\")) {\n            return false;\n        }\n\n        // Check if repository has more items\n        return this.repository.hasMore();\n    }\n}\n\nexport const LoadMoreFeature = Abstraction.createImplementation({\n    implementation: LoadMoreFeatureImpl,\n    dependencies: [ListDataRepository, ListQueryParamsRepository, LoadingRepository]\n});\n"],"names":["LoadMoreFeatureImpl","repository","queryParams","loading","params","LoadMoreFeature","Abstraction","ListDataRepository","ListQueryParamsRepository","LoadingRepository"],"mappings":";AASA,MAAMA;IACF,YACYC,UAAwD,EACxDC,WAAyD,EACzDC,OAAoC,CAC9C;aAHUF,UAAU,GAAVA;aACAC,WAAW,GAAXA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,UAAyB;QAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,IACjB;QAGJ,MAAMC,SAAS,IAAI,CAAC,WAAW,CAAC,GAAG;QAEnC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA,SAAS;IACnE;IAEQ,cAAuB;QAE3B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,aACvB,OAAO;QAIX,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO;IAClC;AACJ;AAEO,MAAMC,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBN;IAChB,cAAc;QAACO;QAAoBC;QAA2BC;KAAkB;AACpF"}

package/features/List/LoadingRepository.d.ts

@@ -0,0 +1,15 @@
+import { type ILoadingRepository } from "./abstractions.js";
+declare class LoadingRepositoryImpl implements ILoadingRepository {
+    private loadingStates;
+    constructor();
+    get(): Record<string, boolean>;
+    set(action: string, isLoading?: boolean): Promise<void>;
+    runCallback<T>(callback: Promise<T>, action: string): Promise<T>;
+    isLoading(action: string): boolean;
+    hasLoading(): boolean;
+    isEmpty(): boolean;
+}
+export declare const LoadingRepository: typeof LoadingRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ILoadingRepository>;
+};
+export {};

package/features/List/LoadingRepository.js

@@ -0,0 +1,48 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { LoadingRepository } from "./abstractions.js";
+class LoadingRepositoryImpl {
+    constructor(){
+        this.loadingStates = {};
+        makeAutoObservable(this, {}, {
+            autoBind: true
+        });
+    }
+    get() {
+        return {
+            ...this.loadingStates
+        };
+    }
+    async set(action, isLoading = true) {
+        runInAction(()=>{
+            if (isLoading) this.loadingStates[action] = true;
+            else delete this.loadingStates[action];
+        });
+    }
+    async runCallback(callback, action) {
+        await this.set(action, true);
+        try {
+            const result = await callback;
+            await this.set(action, false);
+            return result;
+        } catch (error) {
+            await this.set(action, false);
+            throw error;
+        }
+    }
+    isLoading(action) {
+        return true === this.loadingStates[action];
+    }
+    hasLoading() {
+        return Object.keys(this.loadingStates).length > 0;
+    }
+    isEmpty() {
+        return 0 === Object.keys(this.loadingStates).length;
+    }
+}
+const LoadingRepository_LoadingRepository = LoadingRepository.createImplementation({
+    implementation: LoadingRepositoryImpl,
+    dependencies: []
+});
+export { LoadingRepository_LoadingRepository as LoadingRepository };
+
+//# sourceMappingURL=LoadingRepository.js.map

package/features/List/LoadingRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/LoadingRepository.js","sources":["../../../src/features/List/LoadingRepository.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport { LoadingRepository as Abstraction, type ILoadingRepository } from \"./abstractions.js\";\n\nclass LoadingRepositoryImpl implements ILoadingRepository {\n    private loadingStates: Record<string, boolean> = {};\n\n    constructor() {\n        makeAutoObservable(this, {}, { autoBind: true });\n    }\n\n    get(): Record<string, boolean> {\n        return { ...this.loadingStates };\n    }\n\n    async set(action: string, isLoading: boolean = true): Promise<void> {\n        runInAction(() => {\n            if (isLoading) {\n                this.loadingStates[action] = true;\n            } else {\n                delete this.loadingStates[action];\n            }\n        });\n    }\n\n    async runCallback<T>(callback: Promise<T>, action: string): Promise<T> {\n        await this.set(action, true);\n        try {\n            const result = await callback;\n            await this.set(action, false);\n            return result;\n        } catch (error) {\n            await this.set(action, false);\n            throw error;\n        }\n    }\n\n    isLoading(action: string): boolean {\n        return this.loadingStates[action] === true;\n    }\n\n    hasLoading(): boolean {\n        return Object.keys(this.loadingStates).length > 0;\n    }\n\n    isEmpty(): boolean {\n        return Object.keys(this.loadingStates).length === 0;\n    }\n}\n\nexport const LoadingRepository = Abstraction.createImplementation({\n    implementation: LoadingRepositoryImpl,\n    dependencies: []\n});\n"],"names":["LoadingRepositoryImpl","makeAutoObservable","action","isLoading","runInAction","callback","result","error","Object","LoadingRepository","Abstraction"],"mappings":";;AAGA,MAAMA;IAGF,aAAc;aAFN,aAAa,GAA4B,CAAC;QAG9CC,mBAAmB,IAAI,EAAE,CAAC,GAAG;YAAE,UAAU;QAAK;IAClD;IAEA,MAA+B;QAC3B,OAAO;YAAE,GAAG,IAAI,CAAC,aAAa;QAAC;IACnC;IAEA,MAAM,IAAIC,MAAc,EAAEC,YAAqB,IAAI,EAAiB;QAChEC,YAAY;YACR,IAAID,WACA,IAAI,CAAC,aAAa,CAACD,OAAO,GAAG;iBAE7B,OAAO,IAAI,CAAC,aAAa,CAACA,OAAO;QAEzC;IACJ;IAEA,MAAM,YAAeG,QAAoB,EAAEH,MAAc,EAAc;QACnE,MAAM,IAAI,CAAC,GAAG,CAACA,QAAQ;QACvB,IAAI;YACA,MAAMI,SAAS,MAAMD;YACrB,MAAM,IAAI,CAAC,GAAG,CAACH,QAAQ;YACvB,OAAOI;QACX,EAAE,OAAOC,OAAO;YACZ,MAAM,IAAI,CAAC,GAAG,CAACL,QAAQ;YACvB,MAAMK;QACV;IACJ;IAEA,UAAUL,MAAc,EAAW;QAC/B,OAAO,AAA+B,SAA/B,IAAI,CAAC,aAAa,CAACA,OAAO;IACrC;IAEA,aAAsB;QAClB,OAAOM,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG;IACpD;IAEA,UAAmB;QACf,OAAOA,AAA2C,MAA3CA,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM;IACjD;AACJ;AAEO,MAAMC,sCAAoBC,kBAAAA,oBAAgC,CAAC;IAC9D,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

package/features/List/SearchFeature.d.ts

@@ -0,0 +1,10 @@
+import { type ISearchFeature, ListQueryParamsRepository, type BaseListParams } from "./abstractions.js";
+declare class SearchFeatureImpl<TParams extends BaseListParams> implements ISearchFeature {
+    private queryParams;
+    constructor(queryParams: ListQueryParamsRepository.Interface<TParams>);
+    setSearch(query: string): Promise<void>;
+}
+export declare const SearchFeature: typeof SearchFeatureImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ISearchFeature>;
+};
+export {};

package/features/List/SearchFeature.js

@@ -0,0 +1,20 @@
+import { ListQueryParamsRepository, SearchFeature } from "./abstractions.js";
+class SearchFeatureImpl {
+    constructor(queryParams){
+        this.queryParams = queryParams;
+    }
+    async setSearch(query) {
+        await this.queryParams.set((params)=>{
+            params.search = query;
+        });
+    }
+}
+const SearchFeature_SearchFeature = SearchFeature.createImplementation({
+    implementation: SearchFeatureImpl,
+    dependencies: [
+        ListQueryParamsRepository
+    ]
+});
+export { SearchFeature_SearchFeature as SearchFeature };
+
+//# sourceMappingURL=SearchFeature.js.map

package/features/List/SearchFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/SearchFeature.js","sources":["../../../src/features/List/SearchFeature.ts"],"sourcesContent":["import {\n    SearchFeature as Abstraction,\n    type ISearchFeature,\n    ListQueryParamsRepository,\n    type BaseListParams\n} from \"./abstractions.js\";\n\nclass SearchFeatureImpl<TParams extends BaseListParams> implements ISearchFeature {\n    constructor(private queryParams: ListQueryParamsRepository.Interface<TParams>) {}\n\n    async setSearch(query: string): Promise<void> {\n        await this.queryParams.set(params => {\n            params.search = query;\n        });\n    }\n}\n\nexport const SearchFeature = Abstraction.createImplementation({\n    implementation: SearchFeatureImpl,\n    dependencies: [ListQueryParamsRepository]\n});\n"],"names":["SearchFeatureImpl","queryParams","query","params","SearchFeature","Abstraction","ListQueryParamsRepository"],"mappings":";AAOA,MAAMA;IACF,YAAoBC,WAAyD,CAAE;aAA3DA,WAAW,GAAXA;IAA4D;IAEhF,MAAM,UAAUC,KAAa,EAAiB;QAC1C,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,CAAAA;YACvBA,OAAO,MAAM,GAAGD;QACpB;IACJ;AACJ;AAEO,MAAME,8BAAgBC,cAAAA,oBAAgC,CAAC;IAC1D,gBAAgBL;IAChB,cAAc;QAACM;KAA0B;AAC7C"}

package/features/List/SortFeature.d.ts

@@ -0,0 +1,10 @@
+import { type ISortFeature, ListQueryParamsRepository, type BaseListParams } from "./abstractions.js";
+declare class SortFeatureImpl<TParams extends BaseListParams> implements ISortFeature {
+    private queryParams;
+    constructor(queryParams: ListQueryParamsRepository.Interface<TParams>);
+    setSort(by: string, dir: "asc" | "desc"): Promise<void>;
+}
+export declare const SortFeature: typeof SortFeatureImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ISortFeature>;
+};
+export {};

package/features/List/SortFeature.js

@@ -0,0 +1,23 @@
+import { ListQueryParamsRepository, SortFeature } from "./abstractions.js";
+class SortFeatureImpl {
+    constructor(queryParams){
+        this.queryParams = queryParams;
+    }
+    async setSort(by, dir) {
+        await this.queryParams.set((params)=>{
+            params.sort = {
+                by,
+                dir
+            };
+        });
+    }
+}
+const SortFeature_SortFeature = SortFeature.createImplementation({
+    implementation: SortFeatureImpl,
+    dependencies: [
+        ListQueryParamsRepository
+    ]
+});
+export { SortFeature_SortFeature as SortFeature };
+
+//# sourceMappingURL=SortFeature.js.map

package/features/List/SortFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/SortFeature.js","sources":["../../../src/features/List/SortFeature.ts"],"sourcesContent":["import {\n    SortFeature as Abstraction,\n    type ISortFeature,\n    ListQueryParamsRepository,\n    type BaseListParams\n} from \"./abstractions.js\";\n\nclass SortFeatureImpl<TParams extends BaseListParams> implements ISortFeature {\n    constructor(private queryParams: ListQueryParamsRepository.Interface<TParams>) {}\n\n    async setSort(by: string, dir: \"asc\" | \"desc\"): Promise<void> {\n        await this.queryParams.set(params => {\n            params.sort = { by, dir };\n        });\n    }\n}\n\nexport const SortFeature = Abstraction.createImplementation({\n    implementation: SortFeatureImpl,\n    dependencies: [ListQueryParamsRepository]\n});\n"],"names":["SortFeatureImpl","queryParams","by","dir","params","SortFeature","Abstraction","ListQueryParamsRepository"],"mappings":";AAOA,MAAMA;IACF,YAAoBC,WAAyD,CAAE;aAA3DA,WAAW,GAAXA;IAA4D;IAEhF,MAAM,QAAQC,EAAU,EAAEC,GAAmB,EAAiB;QAC1D,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,CAAAA;YACvBA,OAAO,IAAI,GAAG;gBAAEF;gBAAIC;YAAI;QAC5B;IACJ;AACJ;AAEO,MAAME,0BAAcC,YAAAA,oBAAgC,CAAC;IACxD,gBAAgBN;IAChB,cAAc;QAACO;KAA0B;AAC7C"}

package/features/List/abstractions.d.ts

@@ -0,0 +1,73 @@
+export interface BaseListParams {
+    search?: string;
+    sort?: {
+        by: string;
+        dir: "asc" | "desc";
+    };
+    filters?: Record<string, unknown>;
+    limit?: number;
+}
+export interface IListQueryParamsRepository<TParams extends BaseListParams> {
+    get(): TParams;
+    set(updater: (params: TParams) => void): Promise<void>;
+    replace(next: TParams): Promise<void>;
+    reset(): void;
+    subscribe(listener: (next: TParams) => void): () => void;
+    dispose(): void;
+}
+export declare const ListQueryParamsRepository: import("@webiny/di").Abstraction<IListQueryParamsRepository<any>>;
+export declare namespace ListQueryParamsRepository {
+    type Interface<TParams extends BaseListParams = BaseListParams> = IListQueryParamsRepository<TParams>;
+}
+export interface ILoadingRepository {
+    get(): Record<string, boolean>;
+    set(action: string, isLoading?: boolean): Promise<void>;
+    runCallback<T>(callback: Promise<T>, action: string): Promise<T>;
+    isLoading(action: string): boolean;
+    hasLoading(): boolean;
+    isEmpty(): boolean;
+}
+export declare const LoadingRepository: import("@webiny/di").Abstraction<ILoadingRepository>;
+export declare namespace LoadingRepository {
+    type Interface = ILoadingRepository;
+}
+export interface IListDataRepository<TItem, TParams extends BaseListParams> {
+    load(params: TParams): Promise<void>;
+    append(params: TParams): Promise<void>;
+    getAll(): TItem[];
+    hasMore(): boolean;
+    clear(): void;
+}
+export declare const ListDataRepository: import("@webiny/di").Abstraction<IListDataRepository<any, any>>;
+export declare namespace ListDataRepository {
+    type Interface<TItem = any, TParams extends BaseListParams = BaseListParams> = IListDataRepository<TItem, TParams>;
+}
+export interface ISearchFeature {
+    setSearch(query: string): Promise<void>;
+}
+export declare const SearchFeature: import("@webiny/di").Abstraction<ISearchFeature>;
+export declare namespace SearchFeature {
+    type Interface = ISearchFeature;
+}
+export interface IFilterFeature {
+    setFilter(key: string, value: unknown): Promise<void>;
+    clearAllFilters(): Promise<void>;
+}
+export declare const FilterFeature: import("@webiny/di").Abstraction<IFilterFeature>;
+export declare namespace FilterFeature {
+    type Interface = IFilterFeature;
+}
+export interface ISortFeature {
+    setSort(by: string, dir: "asc" | "desc"): Promise<void>;
+}
+export declare const SortFeature: import("@webiny/di").Abstraction<ISortFeature>;
+export declare namespace SortFeature {
+    type Interface = ISortFeature;
+}
+export interface ILoadMoreFeature {
+    execute(): Promise<void>;
+}
+export declare const LoadMoreFeature: import("@webiny/di").Abstraction<ILoadMoreFeature>;
+export declare namespace LoadMoreFeature {
+    type Interface = ILoadMoreFeature;
+}

package/features/List/abstractions.js

@@ -0,0 +1,11 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ListQueryParamsRepository = createAbstraction("ListQueryParamsRepository");
+const LoadingRepository = createAbstraction("LoadingRepository");
+const ListDataRepository = createAbstraction("ListDataRepository");
+const SearchFeature = createAbstraction("SearchFeature");
+const FilterFeature = createAbstraction("FilterFeature");
+const SortFeature = createAbstraction("SortFeature");
+const LoadMoreFeature = createAbstraction("LoadMoreFeature");
+export { FilterFeature, ListDataRepository, ListQueryParamsRepository, LoadMoreFeature, LoadingRepository, SearchFeature, SortFeature };
+
+//# sourceMappingURL=abstractions.js.map

package/features/List/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/abstractions.js","sources":["../../../src/features/List/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\n// ============================================================================\n// Base Types\n// ============================================================================\n\nexport interface BaseListParams {\n    search?: string;\n    sort?: { by: string; dir: \"asc\" | \"desc\" };\n    filters?: Record<string, unknown>;\n    limit?: number;\n}\n\n// ============================================================================\n// Query Params Repository\n// ============================================================================\n\nexport interface IListQueryParamsRepository<TParams extends BaseListParams> {\n    get(): TParams;\n    set(updater: (params: TParams) => void): Promise<void>;\n    replace(next: TParams): Promise<void>;\n    reset(): void;\n    subscribe(listener: (next: TParams) => void): () => void;\n    dispose(): void;\n}\n\nexport const ListQueryParamsRepository = createAbstraction<IListQueryParamsRepository<any>>(\n    \"ListQueryParamsRepository\"\n);\n\nexport namespace ListQueryParamsRepository {\n    export type Interface<TParams extends BaseListParams = BaseListParams> =\n        IListQueryParamsRepository<TParams>;\n}\n\n// ============================================================================\n// Loading Repository\n// ============================================================================\n\nexport interface ILoadingRepository {\n    get(): Record<string, boolean>;\n    set(action: string, isLoading?: boolean): Promise<void>;\n    runCallback<T>(callback: Promise<T>, action: string): Promise<T>;\n    isLoading(action: string): boolean;\n    hasLoading(): boolean;\n    isEmpty(): boolean;\n}\n\nexport const LoadingRepository = createAbstraction<ILoadingRepository>(\"LoadingRepository\");\n\nexport namespace LoadingRepository {\n    export type Interface = ILoadingRepository;\n}\n\n// ============================================================================\n// List Data Repository\n// ============================================================================\n\nexport interface IListDataRepository<TItem, TParams extends BaseListParams> {\n    load(params: TParams): Promise<void>;\n    append(params: TParams): Promise<void>;\n    getAll(): TItem[];\n    hasMore(): boolean;\n    clear(): void;\n}\n\nexport const ListDataRepository =\n    createAbstraction<IListDataRepository<any, any>>(\"ListDataRepository\");\n\nexport namespace ListDataRepository {\n    export type Interface<\n        TItem = any,\n        TParams extends BaseListParams = BaseListParams\n    > = IListDataRepository<TItem, TParams>;\n}\n\n// ============================================================================\n// Features\n// ============================================================================\n\nexport interface ISearchFeature {\n    setSearch(query: string): Promise<void>;\n}\n\nexport const SearchFeature = createAbstraction<ISearchFeature>(\"SearchFeature\");\n\nexport namespace SearchFeature {\n    export type Interface = ISearchFeature;\n}\n\nexport interface IFilterFeature {\n    setFilter(key: string, value: unknown): Promise<void>;\n    clearAllFilters(): Promise<void>;\n}\n\nexport const FilterFeature = createAbstraction<IFilterFeature>(\"FilterFeature\");\n\nexport namespace FilterFeature {\n    export type Interface = IFilterFeature;\n}\n\nexport interface ISortFeature {\n    setSort(by: string, dir: \"asc\" | \"desc\"): Promise<void>;\n}\n\nexport const SortFeature = createAbstraction<ISortFeature>(\"SortFeature\");\n\nexport namespace SortFeature {\n    export type Interface = ISortFeature;\n}\n\nexport interface ILoadMoreFeature {\n    execute(): Promise<void>;\n}\n\nexport const LoadMoreFeature = createAbstraction<ILoadMoreFeature>(\"LoadMoreFeature\");\n\nexport namespace LoadMoreFeature {\n    export type Interface = ILoadMoreFeature;\n}\n"],"names":["ListQueryParamsRepository","createAbstraction","LoadingRepository","ListDataRepository","SearchFeature","FilterFeature","SortFeature","LoadMoreFeature"],"mappings":";AA0BO,MAAMA,4BAA4BC,kBACrC;AAqBG,MAAMC,oBAAoBD,kBAAsC;AAkBhE,MAAME,qBACTF,kBAAiD;AAiB9C,MAAMG,gBAAgBH,kBAAkC;AAWxD,MAAMI,gBAAgBJ,kBAAkC;AAUxD,MAAMK,cAAcL,kBAAgC;AAUpD,MAAMM,kBAAkBN,kBAAoC"}

package/features/List/feature.d.ts

@@ -0,0 +1,8 @@
+export declare const ListFeature: import("@webiny/feature/admin/createFeature.js").FeatureDefinition<{
+    queryParams: import("./abstractions.js").IListQueryParamsRepository<any>;
+    loading: import("./abstractions.js").ILoadingRepository;
+    search: import("./abstractions.js").ISearchFeature;
+    filter: import("./abstractions.js").IFilterFeature;
+    sort: import("./abstractions.js").ISortFeature;
+    loadMore: import("./abstractions.js").ILoadMoreFeature;
+}, []>;

package/features/List/feature.js

@@ -0,0 +1,30 @@
+import { createFeature } from "@webiny/feature/admin/index.js";
+import { FilterFeature, ListQueryParamsRepository, LoadMoreFeature, LoadingRepository, SearchFeature, SortFeature } from "./abstractions.js";
+import { ListQueryParamsRepository as external_ListQueryParamsRepository_js_ListQueryParamsRepository } from "./ListQueryParamsRepository.js";
+import { LoadingRepository as external_LoadingRepository_js_LoadingRepository } from "./LoadingRepository.js";
+import { SearchFeature as external_SearchFeature_js_SearchFeature } from "./SearchFeature.js";
+import { FilterFeature as external_FilterFeature_js_FilterFeature } from "./FilterFeature.js";
+import { SortFeature as external_SortFeature_js_SortFeature } from "./SortFeature.js";
+import { LoadMoreFeature as external_LoadMoreFeature_js_LoadMoreFeature } from "./LoadMoreFeature.js";
+const ListFeature = createFeature({
+    name: "ListFeature",
+    register: (container)=>{
+        container.register(external_ListQueryParamsRepository_js_ListQueryParamsRepository);
+        container.register(external_LoadingRepository_js_LoadingRepository);
+        container.register(external_SearchFeature_js_SearchFeature);
+        container.register(external_FilterFeature_js_FilterFeature);
+        container.register(external_SortFeature_js_SortFeature);
+        container.register(external_LoadMoreFeature_js_LoadMoreFeature);
+    },
+    resolve: (container)=>({
+            queryParams: container.resolve(ListQueryParamsRepository),
+            loading: container.resolve(LoadingRepository),
+            search: container.resolve(SearchFeature),
+            filter: container.resolve(FilterFeature),
+            sort: container.resolve(SortFeature),
+            loadMore: container.resolve(LoadMoreFeature)
+        })
+});
+export { ListFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/List/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/List/feature.js","sources":["../../../src/features/List/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin/index.js\";\nimport {\n    ListQueryParamsRepository as QueryParamsAbstraction,\n    LoadingRepository as LoadingAbstraction,\n    SearchFeature as SearchAbstraction,\n    FilterFeature as FilterAbstraction,\n    SortFeature as SortAbstraction,\n    LoadMoreFeature as LoadMoreAbstraction\n} from \"./abstractions.js\";\nimport { ListQueryParamsRepository } from \"./ListQueryParamsRepository.js\";\nimport { LoadingRepository } from \"./LoadingRepository.js\";\nimport { SearchFeature } from \"./SearchFeature.js\";\nimport { FilterFeature } from \"./FilterFeature.js\";\nimport { SortFeature } from \"./SortFeature.js\";\nimport { LoadMoreFeature } from \"./LoadMoreFeature.js\";\n\nexport const ListFeature = createFeature({\n    name: \"ListFeature\",\n    register: container => {\n        // Register infrastructure\n        container.register(ListQueryParamsRepository);\n        container.register(LoadingRepository);\n\n        // Register features\n        container.register(SearchFeature);\n        container.register(FilterFeature);\n        container.register(SortFeature);\n        container.register(LoadMoreFeature);\n    },\n    resolve: container => {\n        return {\n            queryParams: container.resolve(QueryParamsAbstraction),\n            loading: container.resolve(LoadingAbstraction),\n            search: container.resolve(SearchAbstraction),\n            filter: container.resolve(FilterAbstraction),\n            sort: container.resolve(SortAbstraction),\n            loadMore: container.resolve(LoadMoreAbstraction)\n        };\n    }\n});\n"],"names":["ListFeature","createFeature","container","ListQueryParamsRepository","LoadingRepository","SearchFeature","FilterFeature","SortFeature","LoadMoreFeature","QueryParamsAbstraction","LoadingAbstraction","SearchAbstraction","FilterAbstraction","SortAbstraction","LoadMoreAbstraction"],"mappings":";;;;;;;;AAgBO,MAAMA,cAAcC,cAAc;IACrC,MAAM;IACN,UAAUC,CAAAA;QAENA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QAGnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;IACvB;IACA,SAASN,CAAAA,YACE;YACH,aAAaA,UAAU,OAAO,CAACO;YAC/B,SAASP,UAAU,OAAO,CAACQ;YAC3B,QAAQR,UAAU,OAAO,CAACS;YAC1B,QAAQT,UAAU,OAAO,CAACU;YAC1B,MAAMV,UAAU,OAAO,CAACW;YACxB,UAAUX,UAAU,OAAO,CAACY;QAChC;AAER"}

package/fta/Domain/Models/Meta/Meta.js

@@ -1,19 +1,20 @@
-export class Meta {
-  constructor(meta) {
-    this.totalCount = meta.totalCount;
-    this.cursor = meta.cursor;
-    this.hasMoreItems = meta.hasMoreItems;
-  }
-  static create(meta) {
-    return new Meta(meta);
-  }
-  static createEmpty() {
-    return new Meta({
-      totalCount: 0,
-      cursor: null,
-      hasMoreItems: false
-    });
-  }
+class Meta {
+    constructor(meta){
+        this.totalCount = meta.totalCount;
+        this.cursor = meta.cursor;
+        this.hasMoreItems = meta.hasMoreItems;
+    }
+    static create(meta) {
+        return new Meta(meta);
+    }
+    static createEmpty() {
+        return new Meta({
+            totalCount: 0,
+            cursor: null,
+            hasMoreItems: false
+        });
+    }
 }
+export { Meta };
 
 //# sourceMappingURL=Meta.js.map

package/fta/Domain/Models/Meta/Meta.js.map

@@ -1 +1 @@
-{"version":3,"names":["Meta","constructor","meta","totalCount","cursor","hasMoreItems","create","createEmpty"],"sources":["Meta.ts"],"sourcesContent":["export interface MetaDTO {\n    totalCount: number;\n    cursor: string | null;\n    hasMoreItems: boolean;\n}\n\nexport class Meta {\n    public totalCount: number;\n    public cursor: string | null;\n    public hasMoreItems: boolean;\n\n    protected constructor(meta: MetaDTO) {\n        this.totalCount = meta.totalCount;\n        this.cursor = meta.cursor;\n        this.hasMoreItems = meta.hasMoreItems;\n    }\n\n    static create(meta: MetaDTO) {\n        return new Meta(meta);\n    }\n\n    static createEmpty() {\n        return new Meta({\n            totalCount: 0,\n            cursor: null,\n            hasMoreItems: false\n        });\n    }\n}\n"],"mappings":"AAMA,OAAO,MAAMA,IAAI,CAAC;EAKJC,WAAWA,CAACC,IAAa,EAAE;IACjC,IAAI,CAACC,UAAU,GAAGD,IAAI,CAACC,UAAU;IACjC,IAAI,CAACC,MAAM,GAAGF,IAAI,CAACE,MAAM;IACzB,IAAI,CAACC,YAAY,GAAGH,IAAI,CAACG,YAAY;EACzC;EAEA,OAAOC,MAAMA,CAACJ,IAAa,EAAE;IACzB,OAAO,IAAIF,IAAI,CAACE,IAAI,CAAC;EACzB;EAEA,OAAOK,WAAWA,CAAA,EAAG;IACjB,OAAO,IAAIP,IAAI,CAAC;MACZG,UAAU,EAAE,CAAC;MACbC,MAAM,EAAE,IAAI;MACZC,YAAY,EAAE;IAClB,CAAC,CAAC;EACN;AACJ","ignoreList":[]}
+{"version":3,"file":"fta/Domain/Models/Meta/Meta.js","sources":["../../../../../src/fta/Domain/Models/Meta/Meta.ts"],"sourcesContent":["export interface MetaDTO {\n    totalCount: number;\n    cursor: string | null;\n    hasMoreItems: boolean;\n}\n\nexport class Meta {\n    public totalCount: number;\n    public cursor: string | null;\n    public hasMoreItems: boolean;\n\n    protected constructor(meta: MetaDTO) {\n        this.totalCount = meta.totalCount;\n        this.cursor = meta.cursor;\n        this.hasMoreItems = meta.hasMoreItems;\n    }\n\n    static create(meta: MetaDTO) {\n        return new Meta(meta);\n    }\n\n    static createEmpty() {\n        return new Meta({\n            totalCount: 0,\n            cursor: null,\n            hasMoreItems: false\n        });\n    }\n}\n"],"names":["Meta","meta"],"mappings":"AAMO,MAAMA;IAKT,YAAsBC,IAAa,CAAE;QACjC,IAAI,CAAC,UAAU,GAAGA,KAAK,UAAU;QACjC,IAAI,CAAC,MAAM,GAAGA,KAAK,MAAM;QACzB,IAAI,CAAC,YAAY,GAAGA,KAAK,YAAY;IACzC;IAEA,OAAO,OAAOA,IAAa,EAAE;QACzB,OAAO,IAAID,KAAKC;IACpB;IAEA,OAAO,cAAc;QACjB,OAAO,IAAID,KAAK;YACZ,YAAY;YACZ,QAAQ;YACR,cAAc;QAClB;IACJ;AACJ"}

package/fta/Domain/Models/Meta/MetaMapper.d.ts

@@ -1,4 +1,4 @@
-import type { Meta, MetaDTO } from "./Meta";
+import type { Meta, MetaDTO } from "./Meta.js";
 export declare class MetaMapper {
     static toDto(data: Meta | MetaDTO): MetaDTO;
 }

package/fta/Domain/Models/Meta/MetaMapper.js

@@ -1,11 +1,12 @@
-export class MetaMapper {
-  static toDto(data) {
-    return {
-      totalCount: data.totalCount ?? 0,
-      cursor: data.cursor ?? null,
-      hasMoreItems: data.hasMoreItems ?? false
-    };
-  }
+class MetaMapper {
+    static toDto(data) {
+        return {
+            totalCount: data.totalCount ?? 0,
+            cursor: data.cursor ?? null,
+            hasMoreItems: data.hasMoreItems ?? false
+        };
+    }
 }
+export { MetaMapper };
 
 //# sourceMappingURL=MetaMapper.js.map

package/fta/Domain/Models/Meta/MetaMapper.js.map

@@ -1 +1 @@
-{"version":3,"names":["MetaMapper","toDto","data","totalCount","cursor","hasMoreItems"],"sources":["MetaMapper.ts"],"sourcesContent":["import type { Meta, MetaDTO } from \"./Meta\";\n\nexport class MetaMapper {\n    static toDto(data: Meta | MetaDTO): MetaDTO {\n        return {\n            totalCount: data.totalCount ?? 0,\n            cursor: data.cursor ?? null,\n            hasMoreItems: data.hasMoreItems ?? false\n        };\n    }\n}\n"],"mappings":"AAEA,OAAO,MAAMA,UAAU,CAAC;EACpB,OAAOC,KAAKA,CAACC,IAAoB,EAAW;IACxC,OAAO;MACHC,UAAU,EAAED,IAAI,CAACC,UAAU,IAAI,CAAC;MAChCC,MAAM,EAAEF,IAAI,CAACE,MAAM,IAAI,IAAI;MAC3BC,YAAY,EAAEH,IAAI,CAACG,YAAY,IAAI;IACvC,CAAC;EACL;AACJ","ignoreList":[]}
+{"version":3,"file":"fta/Domain/Models/Meta/MetaMapper.js","sources":["../../../../../src/fta/Domain/Models/Meta/MetaMapper.ts"],"sourcesContent":["import type { Meta, MetaDTO } from \"./Meta.js\";\n\nexport class MetaMapper {\n    static toDto(data: Meta | MetaDTO): MetaDTO {\n        return {\n            totalCount: data.totalCount ?? 0,\n            cursor: data.cursor ?? null,\n            hasMoreItems: data.hasMoreItems ?? false\n        };\n    }\n}\n"],"names":["MetaMapper","data"],"mappings":"AAEO,MAAMA;IACT,OAAO,MAAMC,IAAoB,EAAW;QACxC,OAAO;YACH,YAAYA,KAAK,UAAU,IAAI;YAC/B,QAAQA,KAAK,MAAM,IAAI;YACvB,cAAcA,KAAK,YAAY,IAAI;QACvC;IACJ;AACJ"}

package/fta/Domain/Models/Meta/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./Meta";
-export * from "./MetaMapper";
+export * from "./Meta.js";
+export * from "./MetaMapper.js";

package/fta/Domain/Models/Meta/index.js

@@ -1,4 +1,2 @@
-export * from "./Meta";
-export * from "./MetaMapper";
-
-//# sourceMappingURL=index.js.map
+export * from "./Meta.js";
+export * from "./MetaMapper.js";