@rchemist/listgrid 0.2.6

package/dist/listgrid/config/InlineSubCollectionField.d.ts

@@ -0,0 +1,184 @@
+import { EntityForm } from './EntityForm';
+import { HelpTextType, HiddenType, LabelType, ReadOnlyType, TooltipType } from './Config';
+import { ReactNode } from 'react';
+import { FieldInfoParameters } from './EntityField';
+import { Session } from '../auth/types';
+import { FilterItem, SearchForm } from '../form/SearchForm';
+import { SubCollectionField } from './SubCollectionField';
+import { IListConfig } from '../components/fields/abstract/ListableFormField';
+/**
+ * Inline list field configuration
+ * Allows overriding ListConfig per field
+ */
+export interface InlineListFieldConfig {
+    /** Field name from EntityForm */
+    name: string;
+    /** Override ListConfig options */
+    listConfig?: Partial<IListConfig>;
+}
+/**
+ * Row action button configuration
+ * `item` is a generic row payload — host apps know their own entity shape
+ */
+export interface InlineRowAction {
+    /** Unique action identifier */
+    id: string;
+    /** Button label - static string or function receiving row item */
+    label: string | ((item: any) => string);
+    /** Button icon */
+    icon?: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Click handler - receives row item and entityForm */
+    onClick: (item: any, entityForm: EntityForm, refresh: () => void) => Promise<void>;
+    /** Disable condition */
+    disabled?: (item: any) => boolean;
+    /** Hide condition */
+    hidden?: (item: any) => boolean;
+    /** Confirmation message before execution */
+    confirm?: string | ((item: any) => string);
+}
+/**
+ * Row action column configuration
+ * Allows multiple action columns with different positions and labels
+ */
+export interface InlineRowActionColumn {
+    /** Unique column identifier */
+    id: string;
+    /** Column header label (default: '작업') */
+    label?: string | undefined;
+    /** Column order in the list (default: 9999) */
+    order?: number | undefined;
+    /** Actions to display in this column */
+    actions: InlineRowAction[];
+}
+/**
+ * InlineSubCollectionRelation configuration
+ * Same as SubCollectionRelation but explicitly typed
+ */
+export interface InlineSubCollectionRelation {
+    /** ManyToOne field name in the child entity */
+    mappedBy: string;
+    /** Filter field name (defaults to mappedBy) */
+    filterBy?: string;
+    /** Property to get the value from parent entity (default: 'id') */
+    valueProperty?: string;
+    /** Additional attributes for the subcollection */
+    attributes?: Record<string, any>;
+}
+/**
+ * Pagination options for InlineSubCollectionField
+ */
+export interface InlinePaginationOptions {
+    /** Page size (default: 10) */
+    pageSize?: number;
+    /** Use client-side pagination (load all data first) */
+    clientSide?: boolean;
+}
+/**
+ * Global ListConfig options applied to all fields
+ */
+export interface InlineGlobalListConfig {
+    /** Enable/disable filtering for all fields */
+    filterable?: boolean;
+    /** Enable/disable sorting for all fields */
+    sortable?: boolean;
+    /** Enable/disable quick search */
+    quickSearch?: boolean;
+}
+/**
+ * Fetch options for InlineSubCollectionField
+ */
+export interface InlineSubCollectionFetchOptions {
+    /** Whether to use SearchForm-based fetching (POST request) */
+    useSearchForm?: boolean;
+    /** Page size for fetching */
+    pageSize?: number;
+    /** Whether to use viewDetail mode */
+    viewDetail?: boolean;
+    /** Additional filters to apply */
+    filters?: (entityForm: EntityForm) => Promise<{
+        condition: 'AND' | 'OR';
+        items: FilterItem[];
+    }[]>;
+}
+/**
+ * InlineSubCollectionField configuration
+ * Extends SubCollectionField to display items in a simple list table format
+ * without detail view - only shows list with optional row actions
+ */
+export declare class InlineSubCollectionField extends SubCollectionField {
+    tooltip?: TooltipType | undefined;
+    fetchOptions?: InlineSubCollectionFetchOptions | undefined;
+    /** List fields to display - can be field names or detailed config */
+    inlineListFields?: (string | InlineListFieldConfig)[] | undefined;
+    /** Row action columns - supports multiple action columns */
+    inlineRowActionColumns?: InlineRowActionColumn[] | undefined;
+    /** Pagination options */
+    inlinePagination?: InlinePaginationOptions | undefined;
+    /** Global ListConfig applied to all fields */
+    inlineGlobalListConfig?: InlineGlobalListConfig | undefined;
+    /** Hide title */
+    hideTitle?: boolean | undefined;
+    constructor(props: {
+        entityForm: EntityForm;
+        relation: InlineSubCollectionRelation;
+        order: number;
+        name: string;
+        label?: LabelType | undefined;
+        helpText?: HelpTextType | undefined;
+        hidden?: HiddenType | undefined;
+        readonly?: ReadOnlyType | undefined;
+        listFields?: (string | InlineListFieldConfig)[] | undefined;
+        /** Row action columns - supports multiple action columns */
+        rowActionColumns?: InlineRowActionColumn[] | undefined;
+        pagination?: InlinePaginationOptions | undefined;
+        globalListConfig?: InlineGlobalListConfig | undefined;
+        fetchOptions?: InlineSubCollectionFetchOptions | undefined;
+        hideTitle?: boolean | undefined;
+    });
+    /**
+     * Override withTooltip to support tooltips
+     */
+    withTooltip(tooltip?: TooltipType): this;
+    getTooltip(props: FieldInfoParameters): Promise<ReactNode>;
+    /**
+     * Set list fields to display
+     */
+    withListFields(...fields: (string | InlineListFieldConfig)[]): this;
+    /**
+     * Set row action columns - supports multiple action columns
+     */
+    withRowActionColumns(...columns: InlineRowActionColumn[]): this;
+    /**
+     * Set pagination options
+     */
+    withPagination(options: InlinePaginationOptions): this;
+    /**
+     * Set global ListConfig
+     */
+    withGlobalListConfig(config: InlineGlobalListConfig): this;
+    /**
+     * Set fetch options
+     */
+    withFetchOptions(options: InlineSubCollectionFetchOptions): this;
+    /**
+     * Hide title
+     */
+    withHideTitle(hide?: boolean): this;
+    /**
+     * Override clone to include inline-specific properties
+     */
+    clone(): InlineSubCollectionField;
+    /**
+     * Build the SearchForm for fetching data
+     */
+    buildSearchForm(parentEntityForm: EntityForm): Promise<SearchForm>;
+    /**
+     * Override render to display inline list table
+     */
+    render({ entityForm, session, }: {
+        entityForm: EntityForm;
+        session?: Session;
+    }): Promise<ReactNode | null>;
+}

package/dist/listgrid/config/InlineSubCollectionField.js

@@ -0,0 +1,194 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getConditionalReactNode, } from './Config';
+import React from 'react';
+import { SearchForm } from '../form/SearchForm';
+import { SubCollectionField } from './SubCollectionField';
+/**
+ * InlineSubCollectionField configuration
+ * Extends SubCollectionField to display items in a simple list table format
+ * without detail view - only shows list with optional row actions
+ */
+export class InlineSubCollectionField extends SubCollectionField {
+    constructor(props) {
+        // Call parent constructor
+        super({
+            entityForm: props.entityForm,
+            relation: props.relation,
+            order: props.order,
+            name: props.name,
+            label: props.label,
+            helpText: props.helpText,
+            hidden: props.hidden,
+            readonly: props.readonly,
+        });
+        // Set inline-specific properties
+        this.inlineListFields = props.listFields;
+        this.inlinePagination = props.pagination;
+        this.inlineGlobalListConfig = props.globalListConfig;
+        this.hideTitle = props.hideTitle;
+        this.inlineRowActionColumns = props.rowActionColumns;
+        // Set default fetchOptions
+        const defaultFetchOptions = {
+            useSearchForm: true,
+            viewDetail: false,
+            pageSize: props.pagination?.pageSize ?? 10,
+        };
+        this.fetchOptions = props.fetchOptions
+            ? { ...defaultFetchOptions, ...props.fetchOptions }
+            : defaultFetchOptions;
+    }
+    /**
+     * Override withTooltip to support tooltips
+     */
+    withTooltip(tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+    async getTooltip(props) {
+        return await getConditionalReactNode(props, this.tooltip);
+    }
+    /**
+     * Set list fields to display
+     */
+    withListFields(...fields) {
+        this.inlineListFields = fields;
+        return this;
+    }
+    /**
+     * Set row action columns - supports multiple action columns
+     */
+    withRowActionColumns(...columns) {
+        this.inlineRowActionColumns = columns;
+        return this;
+    }
+    /**
+     * Set pagination options
+     */
+    withPagination(options) {
+        this.inlinePagination = options;
+        return this;
+    }
+    /**
+     * Set global ListConfig
+     */
+    withGlobalListConfig(config) {
+        this.inlineGlobalListConfig = config;
+        return this;
+    }
+    /**
+     * Set fetch options
+     */
+    withFetchOptions(options) {
+        this.fetchOptions = { ...this.fetchOptions, ...options };
+        return this;
+    }
+    /**
+     * Hide title
+     */
+    withHideTitle(hide) {
+        this.hideTitle = hide ?? true;
+        return this;
+    }
+    /**
+     * Override clone to include inline-specific properties
+     */
+    clone() {
+        const cloned = new InlineSubCollectionField({
+            entityForm: this.entityForm,
+            relation: this.relation,
+            order: this.order,
+            name: this.name,
+            label: this.label,
+            helpText: this.helpText,
+            hidden: this.hidden,
+            readonly: this.readonly,
+            listFields: this.inlineListFields,
+            rowActionColumns: this.inlineRowActionColumns,
+            pagination: this.inlinePagination,
+            globalListConfig: this.inlineGlobalListConfig,
+            fetchOptions: this.fetchOptions,
+            hideTitle: this.hideTitle,
+        });
+        cloned.form = this.form;
+        cloned.hideLabel = this.hideLabel;
+        cloned.tooltip = this.tooltip;
+        cloned.listViewFields = this.listViewFields;
+        cloned.viewListOptions = this.viewListOptions;
+        cloned.dynamicUrl = this.dynamicUrl;
+        return cloned;
+    }
+    /**
+     * Build the SearchForm for fetching data
+     */
+    async buildSearchForm(parentEntityForm) {
+        const searchForm = new SearchForm();
+        // Set page size
+        searchForm.withPageSize(this.fetchOptions?.pageSize ?? this.inlinePagination?.pageSize ?? 10);
+        // Set viewDetail mode
+        if (this.fetchOptions?.viewDetail) {
+            searchForm.withViewDetail(true);
+        }
+        // Get the mappedBy filter
+        const mappedByFilter = this.getMappedByFilter(parentEntityForm);
+        // Apply user-defined filters if any
+        if (this.fetchOptions?.filters) {
+            const additionalFilters = await this.fetchOptions.filters(parentEntityForm);
+            if (additionalFilters.length > 0 && additionalFilters[0].items) {
+                // Check if mappedBy filter already exists
+                const hasMappedByFilter = additionalFilters[0].items.some((item) => item.name === mappedByFilter.name);
+                if (!hasMappedByFilter) {
+                    additionalFilters[0].items.unshift(mappedByFilter);
+                }
+                // Apply all filters
+                additionalFilters.forEach((filterGroup) => {
+                    searchForm.withFilter(filterGroup.condition, ...filterGroup.items);
+                });
+            }
+        }
+        else {
+            // Apply only mappedBy filter
+            searchForm.handleAndFilter(mappedByFilter.name, mappedByFilter.value);
+        }
+        return searchForm;
+    }
+    /**
+     * Override render to display inline list table
+     */
+    async render({ entityForm, session, }) {
+        // Lazy load the InlineSubCollectionView component
+        const InlineSubCollectionView = React.lazy(() => import('../components/list/ui/InlineSubCollectionView').then((m) => ({
+            default: m.InlineSubCollectionView,
+        })));
+        // Determine readonly status
+        const readonly = await this.isReadonly({ entityForm, session });
+        // Get tooltip
+        const tooltip = await this.getTooltip({ entityForm, session });
+        // Build initial SearchForm
+        let initialSearchForm;
+        if (this.fetchOptions?.useSearchForm) {
+            initialSearchForm = await this.buildSearchForm(entityForm);
+        }
+        const viewProps = {
+            parentEntityForm: entityForm,
+            parentId: entityForm.id,
+            entityForm: this.entityForm,
+            relation: this.relation,
+            readonly,
+            ...(session !== undefined ? { session } : {}),
+            ...(this.inlineListFields !== undefined ? { listFields: this.inlineListFields } : {}),
+            ...(this.inlineRowActionColumns !== undefined
+                ? { rowActionColumns: this.inlineRowActionColumns }
+                : {}),
+            ...(this.inlinePagination !== undefined ? { pagination: this.inlinePagination } : {}),
+            ...(this.inlineGlobalListConfig !== undefined
+                ? { globalListConfig: this.inlineGlobalListConfig }
+                : {}),
+            ...(this.fetchOptions !== undefined ? { fetchOptions: this.fetchOptions } : {}),
+            ...(initialSearchForm !== undefined ? { initialSearchForm } : {}),
+            tooltip,
+            ...(this.hideTitle !== undefined ? { hideTitle: this.hideTitle } : {}),
+            ...(this.viewListOptions !== undefined ? { viewListOptions: this.viewListOptions } : {}),
+        };
+        return (_jsx(React.Suspense, { fallback: _jsx("div", { className: "rcm-loading-overlay", children: _jsx("div", { className: "rcm-spinner" }) }), children: _jsx(InlineSubCollectionView, { ...viewProps }) }));
+    }
+}

package/dist/listgrid/config/ListGrid.d.ts

@@ -0,0 +1,56 @@
+import { EntityForm } from '../config/EntityForm';
+import { SearchForm } from '../form/SearchForm';
+import { ListableFormField } from '../components/fields/abstract';
+import { LabelType } from '../config/Config';
+import { PageResult } from '../form/Type';
+import { ReactNode } from 'react';
+import { SubCollectionBaseButtonProps } from '../components/list/types/SubCollectionButtons.type';
+export declare class ListGrid {
+    private readonly entityForm;
+    private searchForm?;
+    private listFields?;
+    private overrideFetch?;
+    private overrideFetchResult?;
+    constructor(entityForm: EntityForm);
+    withOverrideFetch(overrideFetch?: (url: string, searchForm: SearchForm) => Promise<PageResult>): this;
+    withOverrideFetchResult(overrideFetchResult?: (result: PageResult) => Promise<PageResult>): this;
+    getListFields(): ListableFormField<any>[];
+    getQuickSearchProperty(findAllFields?: boolean): QuickSearchProps | undefined;
+    getSearchForm(): SearchForm;
+    getEntityForm(): EntityForm;
+    withSearchForm(searchForm: SearchForm): this;
+    fetchData(fetchSearchForm?: SearchForm, extensionOptions?: {
+        entityFormName?: string;
+        extensionPoint?: string;
+    }): Promise<PageResult>;
+    getAdvancedSearchFields(): ListableFormField<any>[];
+}
+export interface SubCollectionProps {
+    name?: string;
+    /**
+     * 이 콜렉션의 엔티티에 상위 엔티티가 어떤 필드명으로 매핑되어 있는지.
+     * 예를 들어 one Plant : many Transceivers 관계에서
+     * Transceiver 엔티티에 plantId = 1 이라는 값으로 매핑되어 있다고 하면 mappedBy 는 plantId 가 되고 mappedValue 는 1이 된다.
+     */
+    mappedBy?: string;
+    mappedValue?: any;
+    buttons?: ((props: SubCollectionBaseButtonProps) => ReactNode)[];
+    add?: boolean;
+    delete?: boolean;
+    modifyOnView?: boolean;
+}
+export interface QuickSearchProps {
+    name: string;
+    label: LabelType;
+    /**
+     * Additional fields to search with OR condition
+     * When specified, quick search will search across all fields using OR condition
+     * @example ['name', 'email', 'phone'] - searches all three fields
+     */
+    orFields?: string[] | undefined;
+    /**
+     * Labels for orFields, used to generate combined placeholder text
+     * @example ['이메일', '전화번호'] for orFields ['email', 'phone']
+     */
+    orFieldLabels?: LabelType[] | undefined;
+}

package/dist/listgrid/config/ListGrid.js

@@ -0,0 +1,183 @@
+import { SearchForm } from '../form/SearchForm';
+import { AbstractManyToOneField, ListableFormField } from '../components/fields/abstract';
+import { isTrue } from '../utils/BooleanUtil';
+import { PageResult } from '../form/Type';
+export class ListGrid {
+    constructor(entityForm) {
+        this.entityForm = entityForm.clone(true);
+    }
+    withOverrideFetch(overrideFetch) {
+        this.overrideFetch = overrideFetch;
+        return this;
+    }
+    withOverrideFetchResult(overrideFetchResult) {
+        this.overrideFetchResult = overrideFetchResult;
+        return this;
+    }
+    getListFields() {
+        if (this.listFields === undefined) {
+            this.listFields = this.entityForm.getListFields();
+        }
+        return this.listFields;
+    }
+    getQuickSearchProperty(findAllFields = true) {
+        let field = undefined;
+        const quickSearchFields = [];
+        const listableFields = [];
+        // 1. 먼저 모든 필드에서 quickSearch: true 가 명시적으로 설정된 필드를 수집
+        // (support 값과 관계없이 quickSearch: true 설정이 있으면 대상이 됨)
+        const allFields = this.entityForm.getFields();
+        allFields.forEach((entityField, idx) => {
+            if (entityField instanceof ListableFormField) {
+                const listConfig = entityField.getListConfig();
+                if (listConfig?.quickSearch) {
+                    // ManyToOneField인 경우 대상 EntityForm에 name 필드가 있으면 .name을 붙여서 검색
+                    if (entityField instanceof AbstractManyToOneField) {
+                        const targetEntityForm = entityField.config?.entityForm;
+                        if (targetEntityForm) {
+                            const nameField = targetEntityForm.getField('name');
+                            if (nameField) {
+                                quickSearchFields.push({
+                                    name: `${entityField.getName()}.name`,
+                                    label: entityField.getLabel(),
+                                    order: idx,
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        quickSearchFields.push({
+                            name: entityField.getName(),
+                            label: entityField.getLabel(),
+                            order: idx,
+                        });
+                    }
+                }
+            }
+        });
+        // 2. listFields 수집 (listableFields 용도)
+        let index = 0;
+        this.getListFields().forEach((listField) => {
+            listableFields.push({ name: listField.getName(), label: listField.getLabel(), order: index });
+            index++;
+        });
+        if (quickSearchFields.length > 0) {
+            field = quickSearchFields[0];
+        }
+        // Fallback: quickSearch: true 필드가 없으면 자동으로 퀵서치 대상 필드 수집
+        // Phase 2: StringField(type=text)만 자동 포함. ManyToOneField는 명시적 quickSearch: true 설정 시에만 Phase 1에서 수집됨
+        if (field === undefined && isTrue(findAllFields) && listableFields.length > 0) {
+            const autoQuickSearchFields = [];
+            this.getListFields().forEach((listField, idx) => {
+                // quickSearch: false가 명시적으로 설정된 필드는 자동탐색에서 제외
+                const listConfig = listField.getListConfig();
+                if (listConfig?.quickSearch === false) {
+                    return;
+                }
+                // filterable: false인 필드는 자동탐색에서 제외
+                if (!listField.isFilterable()) {
+                    return;
+                }
+                // StringField (type === 'text')인 경우만 자동 포함
+                // ManyToOneField는 명시적으로 quickSearch: true를 설정한 경우에만 Phase 1에서 수집됨
+                if (listField.type === 'text') {
+                    autoQuickSearchFields.push({
+                        name: listField.getName(),
+                        label: listField.getLabel(),
+                        order: idx,
+                    });
+                }
+            });
+            // 자동 수집된 필드가 있으면 사용
+            if (autoQuickSearchFields.length > 0) {
+                field = autoQuickSearchFields[0];
+                // 여러 필드가 있으면 OR 조건으로 결합
+                if (autoQuickSearchFields.length > 1) {
+                    const otherFields = autoQuickSearchFields.slice(1);
+                    return {
+                        ...field,
+                        orFields: otherFields.map((f) => f.name),
+                        orFieldLabels: otherFields.map((f) => f.label),
+                    };
+                }
+            }
+        }
+        // Build orFields from multiple quickSearch fields (OR condition support)
+        if (field !== undefined && quickSearchFields.length > 1) {
+            const otherFields = quickSearchFields.filter((f) => f.name !== field.name);
+            const orFields = otherFields.map((f) => f.name);
+            const orFieldLabels = otherFields.map((f) => f.label);
+            return {
+                ...field,
+                orFields: orFields.length > 0 ? orFields : undefined,
+                orFieldLabels: orFieldLabels.length > 0 ? orFieldLabels : undefined,
+            };
+        }
+        return field;
+    }
+    getSearchForm() {
+        if (this.searchForm === undefined) {
+            this.searchForm = SearchForm.create();
+        }
+        return this.searchForm;
+    }
+    getEntityForm() {
+        return this.entityForm;
+    }
+    withSearchForm(searchForm) {
+        this.searchForm = searchForm;
+        return this;
+    }
+    async fetchData(fetchSearchForm, extensionOptions) {
+        const searchForm = fetchSearchForm ?? this.getSearchForm().clone();
+        if (searchForm.isShouldReturnEmpty()) {
+            // should return empty 라면 서버로 굳이 fetch 처리할 필요가 없다.
+            return new PageResult({
+                list: [],
+                totalCount: 0,
+                totalPage: 1,
+                searchForm: searchForm.withPage(0),
+            });
+        }
+        const url = this.getEntityForm().getUrl();
+        /**
+         * 기본 Fetch 로직에 대한 오버라이드가 있다면 해당 로직으로
+         */
+        let result;
+        if (this.overrideFetch !== undefined) {
+            result = await this.overrideFetch(url, searchForm);
+        }
+        else {
+            result = await PageResult.fetchListData(url, searchForm, extensionOptions);
+        }
+        if (this.overrideFetchResult !== undefined) {
+            result = await this.overrideFetchResult(result);
+        }
+        return result;
+    }
+    getAdvancedSearchFields() {
+        const fields = [];
+        const listFields = this.entityForm.getFilterableFields();
+        fields.push(...listFields);
+        if (this.entityForm.appendAdvancedSearchFields) {
+            const appendFields = [];
+            for (const appendField of this.entityForm.appendAdvancedSearchFields) {
+                let duplicated = false;
+                for (const field of fields) {
+                    if (appendField.name === field.name) {
+                        duplicated = true;
+                        break;
+                    }
+                }
+                if (!duplicated) {
+                    appendFields.push(appendField);
+                }
+            }
+            if (appendFields.length > 0) {
+                fields.push(...appendFields);
+                fields.sort((a, b) => a.order - b.order);
+            }
+        }
+        return fields;
+    }
+}

package/dist/listgrid/config/ListGridViewFieldCache.d.ts

@@ -0,0 +1,3 @@
+export declare function getListFieldsFromCache(key: string, postFix?: string): string[] | undefined;
+export declare function setListFieldsToCache(key: string, postFix: string | undefined, fields: string[]): void;
+export declare function clearListFieldsToCache(key: string, postFix: string | undefined): void;

package/dist/listgrid/config/ListGridViewFieldCache.js

@@ -0,0 +1,53 @@
+import { parse, stringify } from '../utils/jsonUtils';
+const cacheKey = 'listGridViewFields';
+class CacheContext {
+    constructor() {
+        this.data = new Map();
+    }
+    static create(value) {
+        const cache = new CacheContext();
+        if (value) {
+            const data = parse(value);
+            cache.data = new Map(Object.entries(data.data));
+        }
+        return cache;
+    }
+    setFields(key, postFix, fields) {
+        const cacheKey = this.createCacheKey(key, postFix);
+        this.data.set(cacheKey, fields);
+    }
+    getFields(key, postFix) {
+        const cacheKey = this.createCacheKey(key, postFix);
+        return this.data.get(cacheKey) ?? [];
+    }
+    clearFields(key, postFix) {
+        const cacheKey = this.createCacheKey(key, postFix);
+        this.data.delete(cacheKey);
+    }
+    createCacheKey(key, postFix) {
+        return key + (postFix ? '_' + postFix : '');
+    }
+    toJson() {
+        return stringify(this);
+    }
+}
+export function getListFieldsFromCache(key, postFix) {
+    if (typeof window === 'undefined')
+        return undefined;
+    const cache = CacheContext.create(localStorage.getItem(cacheKey));
+    return cache.getFields(key, postFix);
+}
+export function setListFieldsToCache(key, postFix, fields) {
+    if (typeof window === 'undefined')
+        return;
+    const cache = CacheContext.create(localStorage.getItem(cacheKey));
+    cache.setFields(key, postFix, fields);
+    localStorage.setItem(cacheKey, cache.toJson());
+}
+export function clearListFieldsToCache(key, postFix) {
+    if (typeof window === 'undefined')
+        return;
+    const cache = CacheContext.create(localStorage.getItem(cacheKey));
+    cache.clearFields(key, postFix);
+    localStorage.setItem(cacheKey, cache.toJson());
+}