@headless-adminapp/app 0.0.17-alpha.54 → 0.0.17-alpha.55

package/toast-notification/hooks/useCloseToastNotification.js

@@ -1,10 +1,13 @@
-import { useCallback } from 'react';
-import { useContextSetValue } from '../../mutable/context';
-import { ToastNotificationContext } from '../context';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCloseToastNotification = useCloseToastNotification;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
 function markToastNotificationAsClosed(items, id) {
     return items.map((item) => {
         if (item.id === id) {
-            return Object.assign(Object.assign({}, item), { isOpen: false });
+            return { ...item, isOpen: false };
         }
         return item;
     });
@@ -12,9 +15,9 @@ function markToastNotificationAsClosed(items, id) {
 function excludeToastNotificationItemById(items, id) {
     return items.filter((item) => item.id !== id);
 }
-export function useCloseToastNotification() {
-    const setValue = useContextSetValue(ToastNotificationContext);
-    const closeDialog = useCallback((id) => {
+function useCloseToastNotification() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.ToastNotificationContext);
+    const closeDialog = (0, react_1.useCallback)((id) => {
         setValue((state) => ({
             items: markToastNotificationAsClosed(state.items, id),
         }));

package/toast-notification/hooks/useOpenToastNotification.js

@@ -1,18 +1,25 @@
-import { useCallback } from 'react';
-import { v4 as uuid } from 'uuid';
-import { useContextSetValue } from '../../mutable/context';
-import { ToastNotificationContext } from '../context';
-import { useCloseToastNotification } from './useCloseToastNotification';
-export function useOpenToastNotification() {
-    const setValue = useContextSetValue(ToastNotificationContext);
-    const closeDialog = useCloseToastNotification();
-    const openToastNotification = useCallback((options) => {
-        const id = uuid();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenToastNotification = useOpenToastNotification;
+const react_1 = require("react");
+const uuid_1 = require("uuid");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+const useCloseToastNotification_1 = require("./useCloseToastNotification");
+function useOpenToastNotification() {
+    const setValue = (0, context_1.useContextSetValue)(context_2.ToastNotificationContext);
+    const closeDialog = (0, useCloseToastNotification_1.useCloseToastNotification)();
+    const openToastNotification = (0, react_1.useCallback)((options) => {
+        const id = (0, uuid_1.v4)();
         setValue((state) => {
             return {
                 items: [
                     ...state.items,
-                    Object.assign({ id, isOpen: true }, options),
+                    {
+                        id,
+                        isOpen: true,
+                        ...options,
+                    },
                 ],
             };
         });

package/toast-notification/hooks/useToastNotificationItems.d.ts

@@ -1 +1 @@
-export declare function useToastNotificationItems(): import("..").ToastNotificationItem[];
+export declare function useToastNotificationItems(): import("../context").ToastNotificationItem[];

package/toast-notification/hooks/useToastNotificationItems.js

@@ -1,5 +1,8 @@
-import { useContextSelector } from '../../mutable/context';
-import { ToastNotificationContext } from '../context';
-export function useToastNotificationItems() {
-    return useContextSelector(ToastNotificationContext, (state) => state.items);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToastNotificationItems = useToastNotificationItems;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useToastNotificationItems() {
+    return (0, context_1.useContextSelector)(context_2.ToastNotificationContext, (state) => state.items);
 }

package/toast-notification/index.js

@@ -1,3 +1,22 @@
-export { ToastNotificationContext, } from './context';
-export { ToastNotificationProvider } from './ToastNotificationProvider';
-export * from './hooks';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToastNotificationProvider = exports.ToastNotificationContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "ToastNotificationContext", { enumerable: true, get: function () { return context_1.ToastNotificationContext; } });
+var ToastNotificationProvider_1 = require("./ToastNotificationProvider");
+Object.defineProperty(exports, "ToastNotificationProvider", { enumerable: true, get: function () { return ToastNotificationProvider_1.ToastNotificationProvider; } });
+__exportStar(require("./hooks"), exports);

package/transport/InMemoryDataService/index.js

@@ -1,13 +1,8 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export class InMemoryDataService {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryDataService = void 0;
+class InMemoryDataService {
+    options;
     // , IActionService, IReportService
     constructor(options) {
         this.options = options;
@@ -25,84 +20,70 @@ export class InMemoryDataService {
         }
         return this.options.data[logicalName];
     }
-    retriveRecord(logicalName, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = this.getSchema(logicalName);
-            const records = this.getCollection(logicalName);
-            const record = records.find((record) => {
-                return record[schema.idAttribute] === id;
-            });
-            if (!record) {
-                throw new Error(`Record with id ${id} not found`);
-            }
-            return record;
+    async retriveRecord(logicalName, id) {
+        const schema = this.getSchema(logicalName);
+        const records = this.getCollection(logicalName);
+        const record = records.find((record) => {
+            return record[schema.idAttribute] === id;
         });
+        if (!record) {
+            throw new Error(`Record with id ${id} not found`);
+        }
+        return record;
     }
-    retriveRecords(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ logicalName, }) {
-            const records = this.getCollection(logicalName);
-            return {
-                logicalName,
-                records: records,
-                count: records.length,
-            };
-        });
+    async retriveRecords({ logicalName, }) {
+        const records = this.getCollection(logicalName);
+        return {
+            logicalName,
+            records: records,
+            count: records.length,
+        };
     }
-    createRecord(logicalName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = this.getSchema(logicalName);
-            const records = this.getCollection(logicalName);
-            const newId = this.options.idGenerator(logicalName, records);
-            const newRecord = Object.assign(Object.assign({}, data), { [schema.idAttribute]: newId });
-            records.push(newRecord);
-            return { id: newId };
-        });
+    async createRecord(logicalName, data) {
+        const schema = this.getSchema(logicalName);
+        const records = this.getCollection(logicalName);
+        const newId = this.options.idGenerator(logicalName, records);
+        const newRecord = {
+            ...data,
+            [schema.idAttribute]: newId,
+        };
+        records.push(newRecord);
+        return { id: newId };
     }
-    updateRecord(logicalName, id, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = this.getSchema(logicalName);
-            const records = this.getCollection(logicalName);
-            const record = records.find((record) => {
-                return record[schema.idAttribute] === id;
-            });
-            if (!record) {
-                throw new Error(`Record with id ${id} not found`);
-            }
-            Object.assign(record, data);
-            return { id };
+    async updateRecord(logicalName, id, data) {
+        const schema = this.getSchema(logicalName);
+        const records = this.getCollection(logicalName);
+        const record = records.find((record) => {
+            return record[schema.idAttribute] === id;
         });
+        if (!record) {
+            throw new Error(`Record with id ${id} not found`);
+        }
+        Object.assign(record, data);
+        return { id };
     }
-    deleteRecord(logicalName, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = this.getSchema(logicalName);
-            const records = this.getCollection(logicalName);
-            const index = records.findIndex((record) => {
-                return record[schema.idAttribute] === id;
-            });
-            if (index === -1) {
-                throw new Error(`Record with id ${id} not found`);
-            }
-            records.splice(index, 1);
+    async deleteRecord(logicalName, id) {
+        const schema = this.getSchema(logicalName);
+        const records = this.getCollection(logicalName);
+        const index = records.findIndex((record) => {
+            return record[schema.idAttribute] === id;
         });
+        if (index === -1) {
+            throw new Error(`Record with id ${id} not found`);
+        }
+        records.splice(index, 1);
     }
-    executeAction() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {};
-        });
+    async executeAction() {
+        return {};
     }
-    getReportData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {};
-        });
+    async getReportData() {
+        return {};
     }
-    retriveAggregate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
+    async retriveAggregate() {
+        return [];
     }
-    customAction() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {};
-        });
+    async customAction() {
+        return {};
     }
 }
+exports.InMemoryDataService = InMemoryDataService;

package/transport/RestDataService/index.d.ts

@@ -16,8 +16,8 @@ export declare class RestDataService implements IDataService {
         [key in keyof T]?: string[];
     }): Promise<Data<T>>;
     retriveRecords<T = unknown>(params: RetriveRecordsFnOptions<T>): Promise<RetriveRecordsResult<T>>;
-    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
-    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core/attributes").Id>>;
+    createRecord<T>(logicalName: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core").Id>>;
+    updateRecord<T>(logicalName: string, id: string, data: Partial<T>): Promise<CreateRecordResult<import("@headless-adminapp/core").Id>>;
     deleteRecord(logicalName: string, id: string): Promise<void>;
     retriveAggregate<Q extends Record<string, AggregateAttribute> = Record<string, AggregateAttribute>>(query: AggregateQuery<Q>): Promise<InferredAggregateQueryResult<Q>[]>;
     customAction<T = unknown>(_actionName: string, _payload: unknown): Promise<T>;

package/transport/RestDataService/index.js

@@ -1,35 +1,31 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { HttpError, } from '@headless-adminapp/core/transport';
-export function handleResponseError(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        if (response.ok) {
-            return;
-        }
-        if ((_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json')) {
-            const data = yield response.json();
-            if (data.error) {
-                throw new HttpError(response.status, data.error);
-            }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestDataService = void 0;
+exports.handleResponseError = handleResponseError;
+const transport_1 = require("@headless-adminapp/core/transport");
+async function handleResponseError(response) {
+    if (response.ok) {
+        return;
+    }
+    if (response.headers.get('content-type')?.includes('application/json')) {
+        const data = await response.json();
+        if (data.error) {
+            throw new transport_1.HttpError(response.status, data.error);
         }
-        throw new HttpError(response.status, response.statusText);
-    });
+    }
+    throw new transport_1.HttpError(response.status, response.statusText);
 }
-export class RestDataService {
+class RestDataService {
+    options;
     constructor(options) {
         this.options = options;
-        this.headers = {};
     }
+    headers = {};
     getHeaders() {
-        return Object.assign({ 'content-type': 'application/json' }, this.headers);
+        return {
+            'content-type': 'application/json',
+            ...this.headers,
+        };
     }
     setHeader(name, value) {
         this.headers[name] = value;
@@ -37,84 +33,69 @@ export class RestDataService {
     removeHeader(name) {
         delete this.headers[name];
     }
-    execute(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(this.options.endpoint, {
-                headers: this.getHeaders(),
-                method: 'POST',
-                body: JSON.stringify(data),
-            });
-            yield handleResponseError(response);
-            return response.json();
+    async execute(data) {
+        const response = await fetch(this.options.endpoint, {
+            headers: this.getHeaders(),
+            method: 'POST',
+            body: JSON.stringify(data),
         });
+        await handleResponseError(response);
+        return response.json();
     }
-    retriveRecord(logicalName, id, columns, expand) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.execute({
-                type: 'retriveRecord',
-                payload: {
-                    logicalName,
-                    id,
-                    columns,
-                    expand,
-                },
-            });
+    async retriveRecord(logicalName, id, columns, expand) {
+        return this.execute({
+            type: 'retriveRecord',
+            payload: {
+                logicalName,
+                id,
+                columns,
+                expand,
+            },
         });
     }
-    retriveRecords(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.execute({
-                type: 'retriveRecords',
-                payload: params,
-            });
+    async retriveRecords(params) {
+        return this.execute({
+            type: 'retriveRecords',
+            payload: params,
         });
     }
-    createRecord(logicalName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.execute({
-                type: 'createRecord',
-                payload: {
-                    logicalName,
-                    data,
-                },
-            });
+    async createRecord(logicalName, data) {
+        return this.execute({
+            type: 'createRecord',
+            payload: {
+                logicalName,
+                data,
+            },
         });
     }
-    updateRecord(logicalName, id, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.execute({
-                type: 'updateRecord',
-                payload: {
-                    logicalName,
-                    id,
-                    data,
-                },
-            });
+    async updateRecord(logicalName, id, data) {
+        return this.execute({
+            type: 'updateRecord',
+            payload: {
+                logicalName,
+                id,
+                data,
+            },
         });
     }
-    deleteRecord(logicalName, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.execute({
-                type: 'deleteRecord',
-                payload: {
-                    logicalName,
-                    id,
-                },
-            });
+    async deleteRecord(logicalName, id) {
+        return this.execute({
+            type: 'deleteRecord',
+            payload: {
+                logicalName,
+                id,
+            },
         });
     }
-    retriveAggregate(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.execute({
-                type: 'retriveAggregate',
-                payload: query,
-            });
-            return result;
+    async retriveAggregate(query) {
+        const result = await this.execute({
+            type: 'retriveAggregate',
+            payload: query,
         });
+        return result;
     }
-    customAction(_actionName, _payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error('Custom action not implemented in RestDataService, to use custom actions, define a custom data service extending RestDataService');
-        });
+    async customAction(_actionName, _payload) {
+        throw new Error('Custom action not implemented in RestDataService, to use custom actions, define a custom data service extending RestDataService');
     }
 }
+exports.RestDataService = RestDataService;

package/transport/context.js

@@ -1,17 +1,11 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { createContext } from 'react';
-export const DataServiceContext = createContext(undefined);
-export const noopFileService = {
-    uploadFile: () => __awaiter(void 0, void 0, void 0, function* () {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileServiceContext = exports.noopFileService = exports.DataServiceContext = void 0;
+const react_1 = require("react");
+exports.DataServiceContext = (0, react_1.createContext)(undefined);
+exports.noopFileService = {
+    uploadFile: async () => {
         throw new Error('File service not implemented');
-    }),
+    },
 };
-export const FileServiceContext = createContext(noopFileService);
+exports.FileServiceContext = (0, react_1.createContext)(exports.noopFileService);

package/transport/hooks/index.js

@@ -1,2 +1,18 @@
-export * from './useDataService';
-export * from './useFileService';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useDataService"), exports);
+__exportStar(require("./useFileService"), exports);

package/transport/hooks/useDataService.js

@@ -1,7 +1,10 @@
-import { useContext } from 'react';
-import { DataServiceContext } from '../context';
-export function useDataService() {
-    const context = useContext(DataServiceContext);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataService = useDataService;
+const react_1 = require("react");
+const context_1 = require("../context");
+function useDataService() {
+    const context = (0, react_1.useContext)(context_1.DataServiceContext);
     if (!context) {
         throw new Error('DataServiceContext must be used within a DataServiceProvider');
     }

package/transport/hooks/useFileService.js

@@ -1,7 +1,10 @@
-import { useContext } from 'react';
-import { FileServiceContext } from '../context';
-export function useFileService() {
-    const context = useContext(FileServiceContext);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFileService = useFileService;
+const react_1 = require("react");
+const context_1 = require("../context");
+function useFileService() {
+    const context = (0, react_1.useContext)(context_1.FileServiceContext);
     if (!context) {
         throw new Error('FileServiceContext must be used within a FileServiceProvider');
     }

package/transport/hooks/useRetriveRecords.d.ts

@@ -11,7 +11,7 @@ interface UseRetriveRecordProps<S extends SchemaAttributes = SchemaAttributes> {
     expand?: Partial<Record<string, string[]>>;
     maxRecords: number;
 }
-export declare function useRetrieveRecordsKey<S extends SchemaAttributes = SchemaAttributes>({ schema, search, filter, sorting, columns, expand, maxRecords, }: UseRetriveRecordProps<S>): (string | number | string[] | Filter | SortingState<S> | Partial<Record<string, string[]>> | null | undefined)[];
+export declare function useRetrieveRecordsKey<S extends SchemaAttributes = SchemaAttributes>({ schema, search, filter, sorting, columns, expand, maxRecords, }: UseRetriveRecordProps<S>): (string | number | string[] | Filter | Partial<Record<string, string[]>> | SortingState<S> | null | undefined)[];
 export declare function useClearDataExceptFirstPage(queryKey: QueryKey): void;
 export declare function useRetriveRecords<S extends SchemaAttributes = SchemaAttributes>(queryKey: QueryKey, { columns, expand, filter, maxRecords, schema, search, sorting, }: UseRetriveRecordProps): {
     data: {