@rchemist/listgrid 0.2.6

package/dist/listgrid/config/SubCollectionField.js

@@ -0,0 +1,241 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_FIELD_GROUP_INFO, DEFAULT_TAB_INFO, getConditionalBoolean, getConditionalReactNode, } from '../config/Config';
+import { ListGrid } from '../config/ListGrid';
+import { isEmpty } from '../utils';
+import { AbstractManyToOneField, ListableFormField } from '../components/fields/abstract';
+import { ViewListGrid } from '../components/list/ViewListGrid';
+export class SubCollectionField {
+    constructor(props) {
+        this.entityForm = props.entityForm;
+        this.relation = props.relation;
+        this.order = props.order;
+        this.name = props.name;
+        this.label = props.label;
+        this.helpText = props.helpText;
+        this.hidden = props.hidden;
+        this.readonly = props.readonly;
+        this.viewListOptions = props.viewListOptions;
+        this.dynamicUrl = props.dynamicUrl;
+    }
+    withTooltip(tooltip) {
+        console.error('not supported');
+        return this;
+    }
+    clone() {
+        const collectionField = new SubCollectionField({
+            entityForm: this.entityForm,
+            relation: this.relation,
+            order: this.order,
+            name: this.name,
+            label: this.label,
+            helpText: this.helpText,
+            hidden: this.hidden,
+            readonly: this.readonly,
+            viewListOptions: this.viewListOptions,
+            dynamicUrl: this.dynamicUrl,
+        });
+        collectionField.form = this.form;
+        collectionField.listViewFields = this.listViewFields;
+        return collectionField;
+    }
+    getTabId() {
+        return this.form?.tabId ?? DEFAULT_TAB_INFO.id;
+    }
+    getFieldGroupId() {
+        return this.form?.fieldGroupId ?? DEFAULT_FIELD_GROUP_INFO.id;
+    }
+    withTabId(tabId) {
+        if (this.form) {
+            this.form.tabId = tabId;
+        }
+        else {
+            this.form = { tabId: tabId, fieldGroupId: DEFAULT_FIELD_GROUP_INFO.id };
+        }
+        return this;
+    }
+    withFieldGroupId(fieldGroupId) {
+        if (this.form) {
+            this.form.fieldGroupId = fieldGroupId;
+        }
+        else {
+            this.form = { tabId: DEFAULT_TAB_INFO.id, fieldGroupId };
+        }
+        return this;
+    }
+    withHelpText(helpText) {
+        this.helpText = helpText;
+        return this;
+    }
+    withHidden(hidden) {
+        this.hidden = hidden;
+        return this;
+    }
+    withLabel(label) {
+        this.label = label;
+        return this;
+    }
+    withReadOnly(readOnly) {
+        this.readonly = readOnly;
+        return this;
+    }
+    withHideLabel(hideLabel) {
+        this.hideLabel = hideLabel;
+        return this;
+    }
+    withOrder(order) {
+        this.order = order;
+        return this;
+    }
+    withViewListGridOptionProps(props) {
+        this.viewListOptions = props;
+        return this;
+    }
+    getViewListGridOptionProps() {
+        return this.viewListOptions ?? {};
+    }
+    getOrder() {
+        return this.order;
+    }
+    getName() {
+        return this.name;
+    }
+    getLabel() {
+        if (this.label) {
+            return this.label;
+        }
+        return this.name;
+    }
+    async getHelpText(props) {
+        return await getConditionalReactNode(props, this.helpText);
+    }
+    async isHidden(props) {
+        return await getConditionalBoolean(props, this.hidden);
+    }
+    async isReadonly(props) {
+        return await getConditionalBoolean(props, this.readonly);
+    }
+    withForm(form) {
+        this.form = form;
+        return this;
+    }
+    withViewPreset(type) {
+        this.hidden = type.hidden;
+        this.readonly = type.readonly;
+        return this;
+    }
+    withListViewFields(...listViewFields) {
+        this.listViewFields = listViewFields;
+        return this;
+    }
+    withDynamicUrl(props) {
+        this.dynamicUrl = props;
+        return this;
+    }
+    getListGrid(parentEntityForm) {
+        const entityForm = this.entityForm.clone(true).withParentId(parentEntityForm.id);
+        if (this.listViewFields !== undefined && !isEmpty(this.listViewFields)) {
+            entityForm.fields.forEach((field, key) => {
+                if (field instanceof ListableFormField) {
+                    if (this.listViewFields.includes(field.name)) {
+                        field.useListField();
+                    }
+                    else {
+                        delete field.listConfig;
+                    }
+                }
+            });
+        }
+        return new ListGrid(entityForm);
+    }
+    async render({ entityForm, session, }) {
+        const listGrid = this.getListGrid(entityForm);
+        const collectionEntityForm = listGrid.getEntityForm();
+        if (this.relation?.subCollectionEntityForm?.manyToOneFilter) {
+            collectionEntityForm.fields.forEach((field, key) => {
+                if (field instanceof AbstractManyToOneField) {
+                    if (this.relation.subCollectionEntityForm?.manyToOneFilter?.[key] !== undefined) {
+                        const filters = this.relation.subCollectionEntityForm.manyToOneFilter[key];
+                        if (!isEmpty(filters)) {
+                            field.config.filter = [...(field.config.filter ?? []), ...filters];
+                        }
+                    }
+                }
+            });
+        }
+        if (this.dynamicUrl !== undefined) {
+            const url = this.dynamicUrl(entityForm);
+            if (url !== undefined) {
+                // url override
+                listGrid.getEntityForm().withUrl(url);
+            }
+        }
+        const readonly = await this.isReadonly({ entityForm, session });
+        const options = this.getViewListGridOptionProps();
+        // 사용자 정의 filters를 저장
+        const userFilters = options.filters;
+        // mappedBy 필터를 항상 포함하도록 filters를 재정의
+        // 서브 콜렉션의 필터에 들어가는 id는 Subcollection 엔티티의 entityForm 의 id 가 아니라 부모의 entityForm 의 id 이다.
+        options.filters = async (ef) => {
+            const mappedByFilter = this.getMappedByFilter(entityForm);
+            if (userFilters) {
+                // 사용자 정의 filters가 있으면 실행하고 mappedBy 필터를 첫 번째 조건에 추가
+                const additionalFilters = await userFilters(ef);
+                if (additionalFilters.length > 0 && additionalFilters[0].items) {
+                    // mappedBy 필터가 이미 있는지 확인하고 없으면 추가
+                    const hasMappedByFilter = additionalFilters[0].items.some((item) => item.name === mappedByFilter.name);
+                    if (!hasMappedByFilter) {
+                        additionalFilters[0].items.unshift(mappedByFilter);
+                    }
+                }
+                return additionalFilters;
+            }
+            // 기본: mappedBy 필터만 반환
+            return [
+                {
+                    condition: 'AND',
+                    items: [mappedByFilter],
+                },
+            ];
+        };
+        if (options.readonly === undefined) {
+            options.readonly = readonly;
+        }
+        const subCollection = {
+            ...this.viewListOptions?.subCollection,
+            name: this.getName(),
+            mappedBy: this.viewListOptions?.subCollection?.mappedBy ?? this.relation.mappedBy,
+            mappedValue: this.viewListOptions?.subCollection?.mappedValue ?? this.getMappedByValue(entityForm),
+        };
+        return Promise.resolve(_jsx(ViewListGrid, { listGrid: listGrid, ...(entityForm.id !== undefined ? { parentId: entityForm.id } : {}), options: {
+                ...options,
+                subCollection: subCollection,
+            } }));
+    }
+    getMappedByFilter(entityForm) {
+        const mappedBy = this.relation.mappedBy;
+        // mappedBy 가 entityId 일 때 이걸 entity.id 로 변환해야 한다.
+        // 연산자 우선순위: ?? 보다 삼항연산자가 먼저 평가되도록 괄호 추가
+        const filterBy = this.relation.filterBy ??
+            (mappedBy.endsWith('Id') ? mappedBy.replace('Id', '') + '.id' : mappedBy);
+        const mappedValue = { name: filterBy };
+        const mappedByValue = this.getMappedByValue(entityForm);
+        if (mappedByValue !== undefined) {
+            mappedValue.value = String(mappedByValue);
+        }
+        return mappedValue;
+    }
+    getMappedByValue(entityForm) {
+        const valueProperty = this.relation.valueProperty ?? 'id';
+        if (valueProperty === 'id') {
+            return entityForm.id;
+        }
+        else {
+            const value = entityForm.getValue(valueProperty);
+            // 타입 안정성: string 또는 number만 반환
+            if (typeof value === 'string' || typeof value === 'number') {
+                return value;
+            }
+            return undefined;
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+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 { SearchForm } from '../form/SearchForm';
+import { SubCollectionField } from './SubCollectionField';
+import { CardSubCollectionFetchOptions, CardSubCollectionRelation } from './CardSubCollectionField';
+/**
+ * Table configuration for TableSubCollectionField
+ */
+export interface TableConfig {
+    /**
+     * Fields to display as columns (whitelist).
+     * If not set, all list-enabled fields are shown.
+     */
+    displayFields?: string[];
+    /**
+     * Fields to exclude from columns (blacklist).
+     */
+    excludeFields?: string[];
+    /**
+     * Page size for client-side pagination.
+     * @default undefined (no pagination)
+     */
+    pageSize?: number;
+    /**
+     * Whether to show row numbers as the first column.
+     * @default true
+     */
+    showRowNumbers?: boolean;
+}
+/**
+ * TableSubCollectionField configuration
+ * Extends SubCollectionField to display items in a table format
+ */
+export declare class TableSubCollectionField extends SubCollectionField {
+    tooltip?: TooltipType | undefined;
+    fetchUrl: string;
+    fetchUrlFunction?: ((parentEntityForm: EntityForm) => string) | undefined;
+    tableConfig?: TableConfig | undefined;
+    fetchOptions?: CardSubCollectionFetchOptions | undefined;
+    constructor(props: {
+        entityForm: EntityForm;
+        relation: CardSubCollectionRelation;
+        order: number;
+        name: string;
+        label?: LabelType | undefined;
+        helpText?: HelpTextType | undefined;
+        hidden?: HiddenType | undefined;
+        readonly?: ReadOnlyType | undefined;
+        fetchUrl?: string | ((parentEntityForm: EntityForm) => string) | undefined;
+        tableConfig?: TableConfig | undefined;
+        fetchOptions?: CardSubCollectionFetchOptions | undefined;
+    });
+    withTooltip(tooltip?: TooltipType): this;
+    getTooltip(props: FieldInfoParameters): Promise<ReactNode>;
+    clone(): TableSubCollectionField;
+    withFetchOptions(fetchOptions: CardSubCollectionFetchOptions): this;
+    withTableConfig(tableConfig: TableConfig): this;
+    buildSearchForm(parentEntityForm: EntityForm): Promise<SearchForm>;
+    render({ entityForm, session, }: {
+        entityForm: EntityForm;
+        session?: Session;
+    }): Promise<ReactNode | null>;
+}

package/dist/listgrid/config/TableSubCollectionField.js

@@ -0,0 +1,132 @@
+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';
+/**
+ * TableSubCollectionField configuration
+ * Extends SubCollectionField to display items in a table format
+ */
+export class TableSubCollectionField extends SubCollectionField {
+    constructor(props) {
+        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,
+        });
+        const defaultFetchOptions = {
+            useSearchForm: true,
+            viewDetail: true,
+            pageSize: 10000,
+        };
+        this.fetchOptions = props.fetchOptions
+            ? { ...defaultFetchOptions, ...props.fetchOptions }
+            : defaultFetchOptions;
+        if (this.fetchOptions.useSearchForm) {
+            this.fetchUrl = props.entityForm.getUrl();
+        }
+        else if (typeof props.fetchUrl === 'function') {
+            this.fetchUrl = props.entityForm.getUrl();
+            this.fetchUrlFunction = props.fetchUrl;
+        }
+        else {
+            this.fetchUrl = props.fetchUrl ?? props.entityForm.getUrl();
+        }
+        this.tableConfig = props.tableConfig;
+    }
+    withTooltip(tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+    async getTooltip(props) {
+        return await getConditionalReactNode(props, this.tooltip);
+    }
+    clone() {
+        const cloned = new TableSubCollectionField({
+            entityForm: this.entityForm,
+            relation: this.relation,
+            order: this.order,
+            name: this.name,
+            label: this.label,
+            helpText: this.helpText,
+            hidden: this.hidden,
+            readonly: this.readonly,
+            fetchUrl: this.fetchUrl,
+            tableConfig: this.tableConfig,
+            fetchOptions: this.fetchOptions,
+        });
+        cloned.form = this.form;
+        cloned.hideLabel = this.hideLabel;
+        cloned.tooltip = this.tooltip;
+        return cloned;
+    }
+    withFetchOptions(fetchOptions) {
+        this.fetchOptions = { ...this.fetchOptions, ...fetchOptions };
+        return this;
+    }
+    withTableConfig(tableConfig) {
+        this.tableConfig = tableConfig;
+        return this;
+    }
+    async buildSearchForm(parentEntityForm) {
+        const searchForm = new SearchForm();
+        searchForm.withPageSize(this.fetchOptions?.pageSize ?? 10000);
+        if (this.fetchOptions?.viewDetail) {
+            searchForm.withViewDetail(true);
+        }
+        const mappedByFilter = this.getMappedByFilter(parentEntityForm);
+        if (this.fetchOptions?.filters) {
+            const additionalFilters = await this.fetchOptions.filters(parentEntityForm);
+            if (additionalFilters.length > 0 && additionalFilters[0].items) {
+                const hasMappedByFilter = additionalFilters[0].items.some((item) => item.name === mappedByFilter.name);
+                if (!hasMappedByFilter) {
+                    additionalFilters[0].items.unshift(mappedByFilter);
+                }
+                additionalFilters.forEach((filterGroup) => {
+                    searchForm.withFilter(filterGroup.condition, ...filterGroup.items);
+                });
+            }
+        }
+        else {
+            searchForm.handleAndFilter(mappedByFilter.name, mappedByFilter.value);
+        }
+        return searchForm;
+    }
+    async render({ entityForm, session, }) {
+        const TableSubCollectionView = React.lazy(() => import('../components/list/ui/TableSubCollectionView').then((m) => ({
+            default: m.TableSubCollectionView,
+        })));
+        let fetchUrl;
+        if (this.fetchUrlFunction) {
+            fetchUrl = this.fetchUrlFunction(entityForm);
+        }
+        else {
+            fetchUrl = this.fetchUrl;
+        }
+        const readonly = await this.isReadonly({ entityForm, session });
+        const tooltip = await this.getTooltip({ entityForm, session });
+        let initialSearchForm;
+        if (this.fetchOptions?.useSearchForm) {
+            initialSearchForm = await this.buildSearchForm(entityForm);
+        }
+        const viewProps = {
+            parentEntityForm: entityForm,
+            parentId: entityForm.id,
+            entityForm: this.entityForm,
+            fetchUrl,
+            ...(this.tableConfig !== undefined ? { tableConfig: this.tableConfig } : {}),
+            relation: this.relation,
+            readonly,
+            ...(session !== undefined ? { session } : {}),
+            ...(this.fetchOptions !== undefined ? { fetchOptions: this.fetchOptions } : {}),
+            ...(initialSearchForm !== undefined ? { initialSearchForm } : {}),
+            tooltip,
+        };
+        return (_jsx(React.Suspense, { fallback: _jsx("div", { className: "rcm-loading-overlay", children: _jsx("div", { className: "rcm-spinner" }) }), children: _jsx(TableSubCollectionView, { ...viewProps }) }));
+    }
+}

package/dist/listgrid/config/form/EntityFormActions.d.ts

@@ -0,0 +1,69 @@
+import { EntityFormData } from './EntityFormData';
+import { IListConfig, ListableFormField } from '../../components/fields/abstract';
+import { CreateStep } from '../../config/Config';
+import { AddFieldItemProps, AlertMessage, DataTransferConfigProps } from '../../config/EntityFormTypes';
+import { DataTransferConfig, DataField } from '../../transfer/Type';
+export declare abstract class EntityFormActions<T extends object = any> extends EntityFormData<T> {
+    constructor(name: string, url: string);
+    getListableFieldOrder(field: ListableFormField<any>): number;
+    /**
+     * Alert 메시지를 제거합니다.
+     * @param includePersistent persistent 메시지도 제거할지 여부 (true면 persistent 메시지도 제거)
+     * @returns EntityForm 인스턴스
+     */
+    clearAlertMessages(includePersistent?: boolean): this;
+    /**
+     * Alert 메시지를 추가합니다.
+     * @param messages 추가할 Alert 메시지 배열
+     * @returns EntityForm 인스턴스
+     */
+    withAlertMessages(messages: AlertMessage[]): this;
+    /**
+     * 특정 키의 Alert 메시지를 제거합니다.
+     * @param key 제거할 메시지의 키
+     * @returns EntityForm 인스턴스
+     */
+    removeAlertMessage(key: string): this;
+    withExcludeListFields(...excludeListFields: string[]): this;
+    /**
+     * 현재 Alert 메시지들을 반환합니다.
+     * @returns Alert 메시지 배열
+     */
+    getAlertMessages(): AlertMessage[];
+    /**
+     * 모든 메시지를 제거합니다. (현재는 Alert 메시지만 지원)
+     * @param includePersistent persistent 메시지도 제거할지 여부 (true면 persistent 메시지도 제거)
+     * @returns EntityForm 인스턴스
+     */
+    clearAllMessages(includePersistent?: boolean): this;
+    withListConfig(fieldName: string, config: IListConfig): this;
+    withCreatedAtField(): this;
+    withCreatedAndUpdatedAtFields(): this;
+    addFields(props: AddFieldItemProps): this;
+    removeField(fieldName: string): void;
+    /**
+     * Field 와 Collection 모두 EntityItem 을 인수로 받기 때문에 둘 간의 차이는 없다.
+     * @param props
+     */
+    addCollections(props: AddFieldItemProps): this;
+    useListFields(...fieldNames: string[]): this;
+    /**
+     * ListGrid 를 그릴 때 getListField() 를 호출하면 자동으로 리스트 필드를 만든다.
+     */
+    getListFields(): ListableFormField<any>[];
+    getFilterableFields(): ListableFormField<any>[];
+    getViewOrder(tabId: string, fieldGroupId: string, fieldOrder: number): number;
+    withDataTransferConfig(props: DataTransferConfigProps): this;
+    private getDataFields;
+    getExportableFields(): Promise<DataField[] | undefined>;
+    getImportableFields(): Promise<DataField[] | undefined>;
+    private getDataFieldsFromFields;
+    getDataTransferConfig(): Promise<DataTransferConfig | undefined>;
+    withFilterable(fieldName: string, filterable?: boolean): this;
+    withNeverDelete(neverDelete?: boolean): this;
+    withStatusCreatedAndUpdatedAtField(): this;
+    withStatusCreatedAtField(): this;
+    getCreateStep(): CreateStep[] | undefined;
+    setCreateStep(createStep?: CreateStep[]): void;
+    withCreateStep(createStep?: CreateStep[]): this;
+}