@headless-adminapp/app 1.1.12 → 1.2.1

package/board/BoardColumnDataResolver.js

@@ -2,24 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataResolver = DataResolver;
 const react_1 = require("react");
+const auth_1 = require("../auth");
 const hooks_1 = require("../hooks");
 const mutable_1 = require("../mutable");
 const useRetriveRecords_1 = require("../transport/hooks/useRetriveRecords");
 const context_1 = require("./context");
 const useBoardColumnConfig_1 = require("./hooks/useBoardColumnConfig");
 const useBoardConfig_1 = require("./hooks/useBoardConfig");
+const useQuickFilter_1 = require("./hooks/useQuickFilter");
 const useSearchText_1 = require("./hooks/useSearchText");
 const MAX_RECORDS = 10000;
 function DataResolver() {
     const { schema, sorting, projection: { columns, expand }, } = (0, useBoardConfig_1.useBoardConfig)();
     const [searchText] = (0, useSearchText_1.useSearchText)();
+    const [quickFilter, quickFilterValues] = (0, useQuickFilter_1.useQuickFilter)();
+    const authSession = (0, auth_1.useAuthSession)();
     const { filter, maxRecords = MAX_RECORDS } = (0, useBoardColumnConfig_1.useBoardColumnConfig)();
     const setState = (0, mutable_1.useContextSetValue)(context_1.BoardColumnContext);
     const [search] = (0, hooks_1.useDebouncedValue)(searchText, 500);
+    const quickFilterResults = (0, react_1.useMemo)(() => {
+        if (!quickFilter) {
+            return null;
+        }
+        if (!quickFilterValues) {
+            return null;
+        }
+        return quickFilter.resolver(quickFilterValues, authSession);
+    }, [authSession, quickFilter, quickFilterValues]);
+    const mergedFilter = (0, react_1.useMemo)(() => {
+        const filters = [];
+        if (filter) {
+            filters.push(filter);
+        }
+        if (quickFilterResults) {
+            filters.push(quickFilterResults);
+        }
+        if (filters.length === 0) {
+            return null;
+        }
+        if (filters.length === 1) {
+            return filters[0];
+        }
+        return {
+            type: 'and',
+            filters,
+        };
+    }, [filter, quickFilterResults]);
     const { fetchNextPage, data, hasNextPage, isFetching, isFetchingNextPage, queryKey, } = (0, useRetriveRecords_1.useRetriveRecords)({
         columns,
         expand,
-        filter,
+        filter: mergedFilter,
         maxRecords,
         schema,
         search,

package/board/context.d.ts

@@ -4,6 +4,7 @@ import { BoardColumnConfig, BoardConfig } from './types';
 export interface BoardContextState<S extends SchemaAttributes = SchemaAttributes> {
     config: BoardConfig<S>;
     searchText: string;
+    quickFilterValues: Record<string, unknown>;
 }
 export interface BoardColumnContextState<S extends SchemaAttributes = SchemaAttributes> {
     config: BoardColumnConfig;

package/board/hooks/useQuickFilter.d.ts

@@ -0,0 +1 @@
+export declare function useQuickFilter(): readonly [import("@headless-adminapp/core/experience/view/QuickFilter").QuickFilter<import("@headless-adminapp/core/schema").SchemaAttributes> | undefined, Record<string, unknown>, (key: string, value: unknown) => void];

package/board/hooks/useQuickFilter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQuickFilter = useQuickFilter;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useQuickFilter() {
+    const quickFilter = (0, context_1.useContextSelector)(context_2.BoardContext, (state) => state.config.quickFilter);
+    const values = (0, context_1.useContextSelector)(context_2.BoardContext, (state) => state.quickFilterValues);
+    const _setValue = (0, context_1.useContextSetValue)(context_2.BoardContext);
+    const setValue = (0, react_1.useCallback)((key, value) => {
+        _setValue((state) => ({
+            quickFilterValues: {
+                ...state.quickFilterValues,
+                [key]: value,
+            },
+        }));
+    }, [_setValue]);
+    return [quickFilter, values, setValue];
+}

package/board/types.d.ts

@@ -1,5 +1,6 @@
 import { CommandContextBase } from '@headless-adminapp/core/experience/command';
 import { SortingState, View } from '@headless-adminapp/core/experience/view';
+import { QuickFilter } from '@headless-adminapp/core/experience/view/QuickFilter';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { Filter } from '@headless-adminapp/core/transport';
 import { FC } from 'react';
@@ -48,4 +49,5 @@ export interface BoardConfig<S extends SchemaAttributes = SchemaAttributes> {
     emptyMessage?: string;
     minColumnWidth?: number;
     maxColumnWidth?: number;
+    quickFilter?: QuickFilter;
 }

package/builders/CommandBuilder/DefaultCommandBuilder.js

@@ -34,6 +34,11 @@ var DefaultCommandBuilder;
                     text: strings.new,
                     localizedTexts: extractLocalizedStrings(localizedSrings, (x) => x.new),
                 }),
+                ViewCommandBuilder_1.ViewCommandBuilder.createNewRecordForVirtualCommand({
+                    Icon: icons.New,
+                    text: strings.new,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, (x) => x.new),
+                }),
                 ViewCommandBuilder_1.ViewCommandBuilder.createEditRecordCommand({
                     Icon: icons.Edit,
                     text: strings.edit,

package/builders/CommandBuilder/ViewCommandBuilder.d.ts

@@ -15,6 +15,11 @@ export declare namespace ViewCommandBuilder {
         text: string;
         localizedTexts?: Record<string, string>;
     }): EntityMainGridCommandItemExperience;
+    function createNewRecordForVirtualCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainGridCommandItemExperience;
     function createEditRecordCommand({ Icon, text, localizedTexts, }: {
         Icon: Icon;
         text: string;

package/builders/CommandBuilder/ViewCommandBuilder.js

@@ -86,6 +86,54 @@ var ViewCommandBuilder;
         };
     }
     ViewCommandBuilder.createNewRecordCommand = createNewRecordCommand;
+    function createNewRecordForVirtualCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: async (context) => {
+                if (!context.primaryControl.schema.baseSchemaLogicalNames?.length) {
+                    return;
+                }
+                const data = await context.utility.openPromptDialog({
+                    title: 'Select type',
+                    attributes: {
+                        type: {
+                            type: 'choice',
+                            label: 'Select type',
+                            string: true,
+                            required: true,
+                            options: context.primaryControl.schema.baseSchemaLogicalNames?.map((x) => {
+                                const schema = context.stores.schemaStore.getSchema(x);
+                                return {
+                                    value: x,
+                                    label: schema.label,
+                                };
+                            }),
+                        },
+                    },
+                    defaultValues: {},
+                });
+                if (!data) {
+                    return;
+                }
+                context.navigation.openForm({
+                    logicalName: data.type,
+                });
+            },
+            hidden: (context) => {
+                if (EnabledRules.IsPhysicalSchema(context)) {
+                    return true;
+                }
+                if (!context.primaryControl.schema.baseSchemaLogicalNames?.length) {
+                    return true;
+                }
+                return false;
+            },
+        };
+    }
+    ViewCommandBuilder.createNewRecordForVirtualCommand = createNewRecordForVirtualCommand;
     function createEditRecordCommand({ Icon, text, localizedTexts, }) {
         return {
             type: 'button',
@@ -94,11 +142,35 @@ var ViewCommandBuilder;
             localizedText: localizedTexts,
             isContextMenu: true,
             onClick: (context) => {
-                context.primaryControl.openRecord(context.primaryControl.selectedIds[0], context.primaryControl.schema.logicalName);
+                if (EnabledRules.IsPhysicalSchema(context)) {
+                    context.primaryControl.openRecord(context.primaryControl.selectedIds[0], context.primaryControl.schema.logicalName);
+                }
+                else {
+                    if (!context.primaryControl.schema.virtualLogicalNameAttribute) {
+                        return;
+                    }
+                    const logicalName = context.primaryControl.selectedRecords[0][context.primaryControl.schema.virtualLogicalNameAttribute];
+                    if (!logicalName) {
+                        return;
+                    }
+                    context.primaryControl.openRecord(context.primaryControl.selectedIds[0], logicalName);
+                }
             },
             hidden: [
                 (context) => !EnabledRules.HasSingleRecordSelected(context),
-                (context) => !EnabledRules.IsPhysicalSchema(context),
+                (context) => {
+                    if (EnabledRules.IsPhysicalSchema(context)) {
+                        return false;
+                    }
+                    if (!context.primaryControl.schema.virtualLogicalNameAttribute) {
+                        return true;
+                    }
+                    const logicalName = context.primaryControl.selectedRecords[0][context.primaryControl.schema.virtualLogicalNameAttribute];
+                    if (!logicalName) {
+                        return true;
+                    }
+                    return false;
+                },
             ],
         };
     }
@@ -115,7 +187,16 @@ var ViewCommandBuilder;
             },
             hidden: [
                 (context) => !EnabledRules.HasSingleRecordSelected(context),
-                (context) => EnabledRules.IsPhysicalSchema(context),
+                (context) => {
+                    if (EnabledRules.IsPhysicalSchema(context)) {
+                        return true;
+                    }
+                    if (context.primaryControl.schema.virtualLogicalNameAttribute ||
+                        context.primaryControl.schema.baseSchemaLogicalName) {
+                        return true;
+                    }
+                    return false;
+                },
             ],
         };
     }

package/builders/DefineViewExperience.d.ts

@@ -1,7 +1,7 @@
 import type { ViewColumn as $ViewColumn, ViewExperience as $ViewExperience } from '@headless-adminapp/core/experience/view';
 import type { SchemaAttributes } from '@headless-adminapp/core/schema';
 export declare namespace DefineViewExperience {
-    export type Experience<S extends SchemaAttributes = SchemaAttributes> = Pick<$ViewExperience<S>, 'filter' | 'defaultSorting' | 'card'> & {
+    export type Experience<S extends SchemaAttributes = SchemaAttributes> = Pick<$ViewExperience<S>, 'filter' | 'defaultSorting' | 'card' | 'quickFilter'> & {
         grid: GridView<S>;
     };
     type GridView<S extends SchemaAttributes = SchemaAttributes> = {

package/builders/SchemaExperienceBuilder.d.ts

@@ -39,7 +39,7 @@ export declare class SchemaExperienceBuilder<S extends SchemaAttributes = Schema
     private readonly defaults?;
     private readonly options?;
     constructor(schema: Schema<S>, defaults?: SchemaExperienceBuilderDefaults | undefined, options?: SchemaExperienceBuilderOptions | undefined);
-    defineViewExperience(viewExperience: Pick<DefineViewExperience.Experience<S>, 'filter' | 'defaultSorting'> & {
+    defineViewExperience(viewExperience: Pick<DefineViewExperience.Experience<S>, 'filter' | 'defaultSorting' | 'quickFilter'> & {
         grid?: DefineViewExperience.Experience<S>['grid'];
         card?: DefineViewExperience.Experience<S>['card'];
     }): ViewExperience<S>;

package/builders/utils.js

@@ -162,7 +162,8 @@ async function retriveRecords({ gridColumns, dataService, schema, search, view,
         search,
         columns: columns,
         expand,
-        filter: (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, columnFilters, schemaStore),
+        filter: (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, null, // quickFilterResults
+        columnFilters, schemaStore),
         skip,
         limit,
         sort: sorting,

package/calendar/CalendarProvider.d.ts

@@ -0,0 +1,8 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { PropsWithChildren } from 'react';
+import { CalendarConfig } from './types';
+interface CalendarProviderProps<SA1 extends SchemaAttributes = SchemaAttributes, SA2 extends SchemaAttributes = SchemaAttributes, SA3 extends SchemaAttributes = SchemaAttributes> {
+    config: CalendarConfig<SA1, SA2, SA3>;
+}
+export declare function CalendarProvider<SA1 extends SchemaAttributes = SchemaAttributes, SA2 extends SchemaAttributes = SchemaAttributes, SA3 extends SchemaAttributes = SchemaAttributes>(props: Readonly<PropsWithChildren<CalendarProviderProps<SA1, SA2, SA3>>>): import("react/jsx-runtime").JSX.Element;
+export {};

package/calendar/CalendarProvider.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarProvider = CalendarProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const mutable_1 = require("../mutable");
+const context_1 = require("./context");
+function CalendarProvider(props) {
+    const contextValue = (0, mutable_1.useCreateContextStore)({
+        config: props.config,
+    });
+    (0, react_1.useEffect)(() => {
+        contextValue.setValue({
+            config: props.config,
+        });
+    }, [contextValue, props.config]);
+    return ((0, jsx_runtime_1.jsx)(context_1.CalendarContext.Provider, { value: contextValue, children: props.children }));
+}

package/calendar/hooks/useDeleteEvent.d.ts

@@ -0,0 +1 @@
+export declare function useDeleteEvent(): (id: string) => Promise<void>;

package/calendar/hooks/useDeleteEvent.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeleteEvent = useDeleteEvent;
+const dialog_1 = require("@headless-adminapp/app/dialog");
+const progress_indicator_1 = require("@headless-adminapp/app/progress-indicator");
+const toast_notification_1 = require("@headless-adminapp/app/toast-notification");
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const useConfig_1 = require("./useConfig");
+function useDeleteEvent() {
+    const openConfirmDialog = (0, dialog_1.useOpenConfirmDialog)();
+    const openToastNotification = (0, toast_notification_1.useOpenToastNotification)();
+    const { hideProgressIndicator, showProgressIndicator } = (0, progress_indicator_1.useProgressIndicator)();
+    const config = (0, useConfig_1.useConfig)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const deleteEvent = (0, react_1.useCallback)(async (id) => {
+        try {
+            if (!config.deleteEvent) {
+                throw new Error('Delete event function is not defined.');
+            }
+            const confirmResult = await openConfirmDialog({
+                title: 'Delete Event',
+                text: 'Are you sure you want to delete this event?',
+            });
+            if (!confirmResult?.confirmed) {
+                return;
+            }
+            showProgressIndicator('Deleting event...');
+            await config.deleteEvent(id);
+            await queryClient.invalidateQueries({
+                queryKey: ['calendar-events'],
+            });
+            close();
+        }
+        catch (error) {
+            openToastNotification({
+                title: 'Error',
+                text: error.message,
+                type: 'error',
+            });
+        }
+        finally {
+            hideProgressIndicator();
+        }
+    }, [
+        config,
+        hideProgressIndicator,
+        openConfirmDialog,
+        openToastNotification,
+        queryClient,
+        showProgressIndicator,
+    ]);
+    return deleteEvent;
+}

package/calendar/hooks/useOpenDetailDialog.d.ts

@@ -0,0 +1,2 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useOpenDetailDialog<SA1 extends SchemaAttributes = SchemaAttributes, SA2 extends SchemaAttributes = SchemaAttributes>(DialogComponent: React.ComponentType<any>): (values: unknown) => void;

package/calendar/hooks/useOpenDetailDialog.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenDetailDialog = useOpenDetailDialog;
+const react_query_1 = require("@tanstack/react-query");
+const useOpenDialog_1 = require("../../dialog/hooks/useOpenDialog");
+const useOpenToastNotification_1 = require("../../toast-notification/hooks/useOpenToastNotification");
+const useConfig_1 = require("./useConfig");
+function useOpenDetailDialog(DialogComponent) {
+    const openDialog = (0, useOpenDialog_1.useOpenDialog)();
+    const openToastNotification = (0, useOpenToastNotification_1.useOpenToastNotification)();
+    const config = (0, useConfig_1.useConfig)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    function openEventDetailModel(values) {
+        const { close } = openDialog({
+            type: 'custom',
+            Component: DialogComponent,
+            props: {
+                onDismiss: () => {
+                    close();
+                },
+                config,
+                values,
+                onSubmit: async (data) => {
+                    if (!config.saveEvent) {
+                        return;
+                    }
+                    try {
+                        const { id, end, start, title, allDay, description, ...rest } = data.values;
+                        await config.saveEvent({
+                            event: {
+                                id,
+                                title,
+                                start: start ? new Date(start) : null,
+                                end: end ? new Date(end) : null,
+                                allDay: allDay ?? false,
+                                description,
+                                ...rest,
+                            },
+                            modifiedValues: data.modifiedValues,
+                        });
+                        await queryClient.invalidateQueries({
+                            queryKey: ['calendar-events'],
+                        });
+                        close();
+                    }
+                    catch (error) {
+                        openToastNotification({
+                            title: 'Error',
+                            text: error.message,
+                            type: 'error',
+                        });
+                    }
+                },
+                onCancel: () => {
+                    close();
+                },
+            },
+        });
+    }
+    return openEventDetailModel;
+}

package/calendar/types.d.ts

@@ -1,5 +1,7 @@
 import { AuthSession } from '@headless-adminapp/core/experience/auth';
+import { OpenFormOptions } from '@headless-adminapp/core/experience/command';
 import { InferredSchemaType, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { InternalRouteResolver, RouterInstance } from '../route/context';
 export interface CalendarEvent {
     id: string;
     title: string;
@@ -28,18 +30,35 @@ export type CalendarEventSaveFn<SA1 extends SchemaAttributes = SchemaAttributes,
 export interface CalendarConfig<SA1 extends SchemaAttributes = SchemaAttributes, SA2 extends SchemaAttributes = SchemaAttributes, SA3 extends SchemaAttributes = SchemaAttributes> {
     eventsResolver: CalendarEventsResolverFn<SA3>;
     eventResolver?: CalendarEventResolverFn;
-    saveEvent: CalendarEventSaveFn<SA1, SA2>;
+    saveEvent?: CalendarEventSaveFn<SA1, SA2>;
     beforeDescriptionAttributes?: SA1;
     afterDescriptionAttributes?: SA2;
     filterAttributes?: SA3;
     defaultFilter?: InferredSchemaType<SA3>;
-    openRecord?: (id: string) => void;
-    deleteEvent: (id: string) => Promise<void>;
+    deleteEvent?: (id: string) => Promise<void>;
     title: string;
     description: string;
     eventLabel: string;
-    disableCreate?: boolean;
-    disableEdit?: boolean;
-    disableDelete?: boolean;
     disableAllDay?: boolean;
+    createOptions?: {
+        mode: 'dialog';
+    } | {
+        mode: 'custom';
+        allowQuickCreate?: boolean;
+        onClick: (defaultValues: Record<string, unknown>, options: {
+            router: RouterInstance;
+            routeResolver: InternalRouteResolver;
+            openForm: (options: OpenFormOptions) => void;
+        }) => void;
+    };
+    editOptions?: {
+        mode: 'dialog';
+    } | {
+        mode: 'custom';
+        onClick: (event: CalendarEvent, options: {
+            router: RouterInstance;
+            routeResolver: InternalRouteResolver;
+            openForm: (options: OpenFormOptions) => void;
+        }) => void;
+    };
 }

package/components/ScrollView/index.js

@@ -15,20 +15,21 @@ const ScrollView = ({ children, className, rtl, autoHide, onScroll, shadowEffect
     const [isTop, setIsTop] = (0, react_1.useState)(true);
     const [isBottom, setIsBottom] = (0, react_1.useState)(false);
     const handleScroll = (event) => {
-        const div = event.target;
-        const remainingSpace = getReaminingSpace(div);
-        const _isTop = div.scrollTop === 0;
-        const _isBottom = remainingSpace <= 0;
+        if (onScroll) {
+            onScroll(event);
+        }
+    };
+    const handleOnUpdate = (values) => {
+        const remainingSpace = values.scrollHeight - values.scrollTop - values.clientHeight;
+        const _isTop = values.scrollTop === 0;
+        const _isBottom = remainingSpace <= 10;
         if (isTop !== _isTop) {
             setIsTop(_isTop);
         }
         if (isBottom !== _isBottom) {
             setIsBottom(_isBottom);
         }
-        if (onScroll) {
-            onScroll(event);
-        }
     };
-    return ((0, jsx_runtime_1.jsx)(react_custom_scrollbars_2_1.Scrollbars, { autoHide: autoHide, className: (0, clsx_1.default)(className, 'hdl-scrollbar', rtl && 'rtl', shadowEffect && !isTop && 'hdl-scrollbar-shadow-top', shadowEffect && !isBottom && 'hdl-scrollbar-shadow-bottom'), onScroll: handleScroll, children: children }));
+    return ((0, jsx_runtime_1.jsx)(react_custom_scrollbars_2_1.Scrollbars, { autoHide: autoHide, className: (0, clsx_1.default)(className, 'hdl-scrollbar', rtl && 'rtl', shadowEffect && !isTop && 'hdl-scrollbar-shadow-top', shadowEffect && !isBottom && 'hdl-scrollbar-shadow-bottom'), onScroll: handleScroll, onUpdate: handleOnUpdate, children: children }));
 };
 exports.ScrollView = ScrollView;

package/dataform/utils/index.js

@@ -33,6 +33,8 @@ const utils_1 = require("../../dataform/DataFormProvider/utils");
 const utils_2 = require("../../locale/utils");
 var saveRecord_1 = require("./saveRecord");
 Object.defineProperty(exports, "saveRecord", { enumerable: true, get: function () { return saveRecord_1.saveRecord; } });
+const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const objectIdRegex = /^[0-9a-f]{24}$/i;
 function getInitialValues({ cloneRecord, form, record, recordId, schema, defaultParameters, }) {
     const formColumns = (0, utils_1.getColumns)(form, schema);
     const editableGridControls = (0, utils_1.getControls)(form).filter((control) => control.type === 'editablegrid' && control.alias !== false);
@@ -253,6 +255,14 @@ function createAttributeValidationSchema(attribute) {
         case 'lookups':
             validationSchema = yup.array().nullable();
             break;
+        case 'id':
+            if ('number' in attribute && attribute.number) {
+                validationSchema = yup.number().nullable();
+            }
+            else {
+                validationSchema = yup.string().nullable();
+            }
+            break;
         default:
             validationSchema = yup.mixed().nullable();
             break;
@@ -284,6 +294,14 @@ function extendAttributeValidationSchema({ attribute, validationSchema, label, s
                 strings,
             });
             break;
+        case 'id':
+            validationSchema = extendAttributeIdValidationSchema({
+                attribute,
+                validationSchema: validationSchema,
+                label,
+                strings,
+            });
+            break;
         default:
             break;
     }
@@ -337,6 +355,15 @@ function extendAttributeAttachmentsValidationSchema({ attribute, validationSchem
     }
     return validationSchema;
 }
+function extendAttributeIdValidationSchema({ attribute, validationSchema, label, strings, }) {
+    if ('guid' in attribute && attribute.guid) {
+        validationSchema = validationSchema.matches(guidRegex, `${label}: ${strings.invalidIdFormat}`);
+    }
+    else if ('objectId' in attribute && attribute.objectId) {
+        validationSchema = validationSchema.matches(objectIdRegex, `${label}: ${strings.invalidIdFormat}`);
+    }
+    return validationSchema;
+}
 exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings, region) {
     let validationSchema = createAttributeValidationSchema(attribute);
     const label = (0, utils_2.localizedLabel)(language, attribute);

package/datagrid/DataGridProvider/DataResolver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataResolver = DataResolver;
 const react_1 = require("react");
+const auth_1 = require("../../auth");
 const hooks_1 = require("../../hooks");
 const useDebouncedValue_1 = require("../../hooks/useDebouncedValue");
 const useMetadata_1 = require("../../metadata/hooks/useMetadata");
@@ -10,6 +11,7 @@ const useRetriveRecords_1 = require("../../transport/hooks/useRetriveRecords");
 const context_2 = require("../context");
 const hooks_2 = require("../hooks");
 const useGridDisabled_1 = require("../hooks/useGridDisabled");
+const useQuickFilter_1 = require("../hooks/useQuickFilter");
 const utils_1 = require("./utils");
 function DataResolver() {
     const schema = (0, hooks_2.useDataGridSchema)();
@@ -22,6 +24,8 @@ function DataResolver() {
     const maxRecords = (0, hooks_2.useMaxRecords)();
     const [selectedIds] = (0, hooks_2.useGridSelection)();
     const disabled = (0, useGridDisabled_1.useGridDisabled)();
+    const [quickFilter, quickFilterValues] = (0, useQuickFilter_1.useQuickFilter)();
+    const authSession = (0, auth_1.useAuthSession)();
     const { schemaStore } = (0, useMetadata_1.useMetadata)();
     const selectedIdsRef = (0, react_1.useRef)(selectedIds);
     selectedIdsRef.current = selectedIds;
@@ -37,9 +41,25 @@ function DataResolver() {
     const expand = (0, react_1.useMemo)(() => isMobile
         ? (0, utils_1.collectCardExpandedKeys)({ cardView: view.experience.card })
         : (0, utils_1.collectExpandedKeys)(gridColumns), [gridColumns, isMobile, view.experience.card]);
+    const quickFilterResults = (0, react_1.useMemo)(() => {
+        if (!quickFilter) {
+            return null;
+        }
+        if (!quickFilterValues) {
+            return null;
+        }
+        return quickFilter.resolver(quickFilterValues, authSession);
+    }, [authSession, quickFilter, quickFilterValues]);
     const filter = (0, react_1.useMemo)(() => {
-        return (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, columnFilters, schemaStore);
-    }, [columnFilters, extraFilter, schema, schemaStore, view.experience.filter]);
+        return (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, quickFilterResults, columnFilters, schemaStore);
+    }, [
+        columnFilters,
+        extraFilter,
+        schema,
+        schemaStore,
+        view.experience.filter,
+        quickFilterResults,
+    ]);
     const { fetchNextPage, data, hasNextPage, isFetching, isFetchingNextPage, queryKey, } = (0, useRetriveRecords_1.useRetriveRecords)({
         columns,
         expand,

package/datagrid/DataGridProvider/index.js

@@ -28,6 +28,7 @@ function DataGridProvider(props) {
         searchText: '',
         selectedIds: [],
         sorting: props.view.experience.defaultSorting ?? [],
+        quickFilterValues: props.view.experience.quickFilter?.defaultValues ?? {},
         view: props.view,
         commands: props.commands,
         columns: (0, transformViewColumns_1.transformViewColumns)(props.view.logicalName, props.view.experience.grid.columns, schemaStore, language),
@@ -52,6 +53,7 @@ function DataGridProvider(props) {
             searchText: '',
             selectedIds: [],
             sorting: props.view.experience.defaultSorting ?? [],
+            quickFilterValues: props.view.experience.quickFilter?.defaultValues ?? {},
             columns: (0, transformViewColumns_1.transformViewColumns)(props.view.logicalName, props.view.experience.grid.columns, schemaStore, language),
             maxRecords: props.maxRecords,
         });

package/datagrid/DataGridProvider/utils.d.ts

@@ -4,7 +4,8 @@ import { ISchemaStore } from '@headless-adminapp/core/store';
 import { Filter } from '@headless-adminapp/core/transport';
 import { TransformedViewColumn } from '../context';
 export declare function transformColumnFilter<S extends SchemaAttributes = SchemaAttributes>(filter: Partial<Record<string, ColumnCondition>>, schema: Schema<S>, schemaStore: ISchemaStore): Record<string, ColumnCondition> | null;
-export declare function mergeConditions<S extends SchemaAttributes = SchemaAttributes>(schema: Schema<S>, filter: Filter | null | undefined, extraFilter: Filter | null | undefined, columnFilters: Partial<Record<string, ColumnCondition>> | undefined, schemaStore: ISchemaStore): Filter | null;
+export declare function mergeConditions<S extends SchemaAttributes = SchemaAttributes>(schema: Schema<S>, filter: Filter | null | undefined, extraFilter: Filter | null | undefined, quickFilterResults: Filter | null | undefined, columnFilters: Partial<Record<string, ColumnCondition>> | undefined, schemaStore: ISchemaStore): Filter | null;
+export declare function simplyfyFilter(filter: Filter): Filter | null;
 export declare function collectExpandedKeys(columns: TransformedViewColumn<SchemaAttributes>[]): Record<string, string[]>;
 export declare function collectGridColumns<S extends SchemaAttributes = SchemaAttributes>({ gridColumns, schema, }: {
     gridColumns: TransformedViewColumn<S>[];

package/datagrid/DataGridProvider/utils.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformColumnFilter = transformColumnFilter;
 exports.mergeConditions = mergeConditions;
+exports.simplyfyFilter = simplyfyFilter;
 exports.collectExpandedKeys = collectExpandedKeys;
 exports.collectGridColumns = collectGridColumns;
 exports.collectCardColumns = collectCardColumns;
@@ -77,7 +78,7 @@ function transformColumnFilter(filter, schema, schemaStore) {
     }
     return transformedResult;
 }
-function mergeConditions(schema, filter, extraFilter, columnFilters, schemaStore) {
+function mergeConditions(schema, filter, extraFilter, quickFilterResults, columnFilters, schemaStore) {
     const filters = [];
     if (filter) {
         filters.push(filter);
@@ -85,6 +86,9 @@ function mergeConditions(schema, filter, extraFilter, columnFilters, schemaStore
     if (extraFilter) {
         filters.push(extraFilter);
     }
+    if (quickFilterResults) {
+        filters.push(quickFilterResults);
+    }
     if (columnFilters) {
         const transformedColumnFilters = transformColumnFilter(columnFilters, schema, schemaStore);
         if (transformedColumnFilters) {
@@ -105,11 +109,42 @@ function mergeConditions(schema, filter, extraFilter, columnFilters, schemaStore
         return null;
     }
     if (filters.length === 1) {
-        return filters[0];
+        return simplyfyFilter(filters[0]);
     }
-    return {
+    return simplyfyFilter({
         type: 'and',
         filters: filters,
+    });
+}
+function simplyfyFilter(filter) {
+    const conditions = filter.conditions ?? [];
+    const filters = [];
+    if (filter.filters) {
+        for (const f of filter.filters) {
+            const _f = simplyfyFilter(f);
+            if (!_f) {
+                continue;
+            }
+            if (_f.type !== filter.type) {
+                filters.push(_f);
+            }
+            else {
+                if (_f.conditions) {
+                    conditions.push(..._f.conditions);
+                }
+                if (_f.filters) {
+                    filters.push(..._f.filters);
+                }
+            }
+        }
+    }
+    if (conditions.length === 0 && filters.length === 0) {
+        return null;
+    }
+    return {
+        type: filter.type,
+        conditions: conditions,
+        filters: filters,
     };
 }
 function collectExpandedKeys(columns) {

package/datagrid/context.d.ts

@@ -23,6 +23,7 @@ export interface GridContextState<S extends SchemaAttributes = SchemaAttributes,
     searchText: string;
     columnFilters: Partial<Record<keyof S, ColumnCondition>>;
     sorting: SortingState<S>;
+    quickFilterValues: Record<string, unknown>;
     selectedIds: string[];
     data: RetriveRecordsResult<InferredSchemaType<S>> | null;
     dataState: {

package/datagrid/hooks/useQuickFilter.d.ts

@@ -0,0 +1 @@
+export declare function useQuickFilter(): readonly [import("@headless-adminapp/core/experience/view/QuickFilter").QuickFilter<import("@headless-adminapp/core/schema").SchemaAttributes> | undefined, Record<string, unknown>, (key: string, value: unknown) => void];

package/datagrid/hooks/useQuickFilter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQuickFilter = useQuickFilter;
+const react_1 = require("react");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useQuickFilter() {
+    const quickFilter = (0, context_1.useContextSelector)(context_2.GridContext, (state) => state.view.experience.quickFilter);
+    const values = (0, context_1.useContextSelector)(context_2.GridContext, (state) => state.quickFilterValues);
+    const _setValue = (0, context_1.useContextSetValue)(context_2.GridContext);
+    const setValue = (0, react_1.useCallback)((key, value) => {
+        _setValue((state) => ({
+            quickFilterValues: {
+                ...state.quickFilterValues,
+                [key]: value,
+            },
+        }));
+    }, [_setValue]);
+    return [quickFilter, values, setValue];
+}

package/form/FormValidationStringContext.d.ts

@@ -7,6 +7,7 @@ export interface FormValidationStringSet {
     invalidPhoneNumber: string;
     atLeastOneRowRequired: string;
     fileSizeExceeded: string;
+    invalidIdFormat: string;
 }
 export declare const defaultFormValidationStrings: FormValidationStringSet;
 export declare const FormValidationStringContext: import("react").Context<FormValidationStringSet>;

package/form/FormValidationStringContext.js

@@ -12,6 +12,7 @@ exports.defaultFormValidationStrings = {
     invalidPhoneNumber: 'Invalid phone number.',
     atLeastOneRowRequired: 'At least one row required.',
     fileSizeExceeded: 'File size exceeded.',
+    invalidIdFormat: 'Invalid ID format.',
 };
 exports.FormValidationStringContext = (0, react_1.createContext)(exports.defaultFormValidationStrings);
 function useFormValidationStrings() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "1.1.12",
+  "version": "1.2.1",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -36,5 +36,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "ead918f1f609c2a260ceae498368ddc2c4980725"
+  "gitHead": "1cf9322dda84c1898cc90f1e92278b79ed9f2902"
 }

package/recordset/RecordSetProvider.js

@@ -28,7 +28,7 @@ const CardViewSetter = () => {
             return;
         }
         experienceStore
-            .getViewLookupV2(logicalName)
+            .getPublicView(logicalName)
             .then((view) => {
             setValue({
                 cardView: view.experience.card,

package/recordset/hooks/useRecordSetResult.js

@@ -29,6 +29,7 @@ function useRecordSetResult() {
             ...(cardView.secondaryColumns ?? [])
                 .filter((x) => !x.expandedKey)
                 .map((x) => x.name),
+            ...(cardView.rightColumn ?? []).map((x) => x.name),
         ])).filter(Boolean);
     }, [cardView]);
     const { isPending, data, error } = (0, react_query_1.useQuery)({

package/transport/hooks/useRetriveRecords.js

@@ -7,6 +7,7 @@ exports.useRetriveRecords = useRetriveRecords;
 const transport_1 = require("@headless-adminapp/app/transport");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
+const utils_1 = require("../../datagrid/DataGridProvider/utils");
 const ROWS_PER_PAGE = 100;
 const MAX_RECORDS = 10000;
 function useRetrieveRecordsKey({ schema, search, filter, sorting, columns, expand, maxRecords, }) {
@@ -125,10 +126,16 @@ function useRetriveRecordsInternal(queryKey, { columns, expand, filter, maxRecor
     };
 }
 function useRetriveRecords({ columns, expand, filter, maxRecords, schema, search, sorting, disabled, }) {
+    const _filter = (0, react_1.useMemo)(() => {
+        if (!filter) {
+            return null;
+        }
+        return (0, utils_1.simplyfyFilter)(filter);
+    }, [filter]);
     const queryKey = useRetrieveRecordsKey({
         columns,
         expand,
-        filter,
+        filter: _filter,
         maxRecords,
         schema,
         search,
@@ -137,7 +144,7 @@ function useRetriveRecords({ columns, expand, filter, maxRecords, schema, search
     const query = useRetriveRecordsInternal(queryKey, {
         columns,
         expand,
-        filter,
+        filter: _filter,
         maxRecords,
         schema,
         search,