@rchemist/listgrid 0.2.6

package/dist/listgrid/components/fields/HtmlField.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { MarkdownEditor } from '../../ui';
+import { isEquals } from '../../misc';
+import { isBlank } from '../../utils/StringUtil';
+export class HtmlField extends FormField {
+    constructor(name, order) {
+        super(name, order, 'markdown');
+    }
+    /**
+     * HtmlField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            return _jsx(MarkdownEditor, { ...await getInputRendererParameters(this, params) });
+        })();
+    }
+    /**
+     * View mode: render HTML content with dangerouslySetInnerHTML
+     */
+    async renderViewInstance(props) {
+        const value = props.item[this.name];
+        if (value === null || value === undefined || value === '') {
+            return { result: null };
+        }
+        return {
+            result: _jsx("div", { dangerouslySetInnerHTML: { __html: String(value) } }),
+        };
+    }
+    /**
+     * HtmlField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new HtmlField(name, order);
+    }
+    isEqualsOrEmpty(value) {
+        if (isBlank(value))
+            return true;
+        return value === '<p><br></p>' || value === '<p></p>';
+    }
+    isDirty() {
+        if (this.value) {
+            const isNullDefaultValue = this.isEqualsOrEmpty(this.value.default);
+            const isNullFetchedValue = this.isEqualsOrEmpty(this.value.fetched);
+            const isNullCurrentValue = this.isEqualsOrEmpty(this.value.current);
+            if (isNullDefaultValue && isNullFetchedValue && isNullCurrentValue) {
+                return false;
+            }
+            if (this.value.fetched !== undefined) {
+                // fetch 된 값이 존재할 때는 fetched 된 값과 비교한다.
+                if (isNullFetchedValue && isNullCurrentValue) {
+                    return false;
+                }
+                return !isEquals(this.value.fetched, this.value.current);
+            }
+            else {
+                // fetch 된 값이 없을 때는 default 값과 비교한다.
+                if (isNullDefaultValue && isNullCurrentValue) {
+                    return false;
+                }
+                return !isEquals(this.value.default, this.value.current);
+            }
+        }
+        return false;
+    }
+    static create(props) {
+        return new HtmlField(props.name, props.order).copyFields(props);
+    }
+}

package/dist/listgrid/components/fields/ImageField.d.ts

@@ -0,0 +1,34 @@
+import { ListableFormField, ListableFormFieldProps, ViewListProps, ViewListResult } from './abstract';
+import React from 'react';
+import { IAssetConfig } from '../../config/Config';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+interface ImageFieldProps extends ListableFormFieldProps {
+    config?: IAssetConfig | undefined;
+}
+export declare class ImageField extends ListableFormField<ImageField> {
+    config?: IAssetConfig | undefined;
+    constructor(name: string, order: number, config?: IAssetConfig);
+    withConfig(config?: IAssetConfig): this;
+    withMaxSize(maxSize?: number): this;
+    withMaxCount(maxCount?: number): this;
+    withExtensions(...extension: string[]): this;
+    withFileTypes(...fileTypes: string[]): this;
+    /**
+     * ImageField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * ImageField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): ImageField;
+    /**
+     * ImageField 리스트 필터 렌더링 (기본 텍스트 입력)
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * ImageField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    static create(props: ImageFieldProps): ImageField;
+}
+export {};

package/dist/listgrid/components/fields/ImageField.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ListableFormField, } from './abstract';
+import { LazyFileUploadInput as FileUploadInput } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { isEmpty } from '../../utils';
+import { getAccessableAssetUrl } from '../../misc';
+import { TextInput } from '../../ui';
+export class ImageField extends ListableFormField {
+    constructor(name, order, config) {
+        super(name, order, 'file');
+        this.config = config;
+        this.listConfig = {
+            filterable: false,
+            sortable: false,
+        };
+    }
+    withConfig(config) {
+        this.config = config;
+        return this;
+    }
+    withMaxSize(maxSize) {
+        this.config = {
+            maxSize: maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withMaxCount(maxCount) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withExtensions(...extension) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: extension,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withFileTypes(...fileTypes) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: fileTypes,
+        };
+        return this;
+    }
+    /**
+     * ImageField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        return (async () => {
+            let config = this.config;
+            if (!config) {
+                config = {
+                    maxCount: 1,
+                    extensions: ['png', 'jpeg', 'jpg', 'gif', 'webp', 'svg'],
+                    fileTypes: ['image/*'],
+                };
+            }
+            else {
+                if (!config.fileTypes) {
+                    config.fileTypes = ['image/*'];
+                }
+                if (!config.extensions) {
+                    config.extensions = ['png', 'jpeg', 'jpg', 'gif', 'webp', 'svg'];
+                }
+                if (!config.maxCount || config.maxCount < 1) {
+                    config.maxCount = 1;
+                }
+            }
+            return (_jsx(FileUploadInput, { config: config, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * ImageField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new ImageField(name, order, this.config);
+    }
+    /**
+     * ImageField 리스트 필터 렌더링 (기본 텍스트 입력)
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(TextInput, { name: `${this.name}_${params.entityForm.id}`, onChange: (value) => params.onChange(value, 'LIKE'), value: params.value }));
+        })();
+    }
+    /**
+     * ImageField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    renderListItemInstance(props) {
+        return (async () => {
+            const value = await props.item;
+            if (value[this.name]) {
+                const file = value[this.name];
+                if (!isEmpty(file.existFiles)) {
+                    const imgUrl = getAccessableAssetUrl(file.existFiles[0].url);
+                    return {
+                        result: (_jsx("div", { className: "rcm-image-field-cell", children: _jsxs("div", { className: "rcm-image-field-hover-group", children: [_jsx("img", { className: "rcm-image-field-thumb", src: `${imgUrl}`, onError: (event) => {
+                                            event.currentTarget.src = '/assets/images/no-image.png';
+                                        }, alt: "primary image" }), _jsx("div", { className: "rcm-image-field-preview-wrap", children: _jsx("img", { className: "rcm-image-field-preview", src: `${imgUrl}`, onError: (event) => {
+                                                event.currentTarget.src = '/assets/images/no-image.png';
+                                            }, alt: "enlarged image" }) })] }) })),
+                    };
+                }
+            }
+            return {
+                result: (_jsx("div", { className: "rcm-image-field-cell", children: _jsx("img", { className: "rcm-image-field-thumb rcm-image-field-thumb-placeholder", src: `/assets/images/no-image.png`, alt: "no image" }) })),
+            };
+        })();
+    }
+    static create(props) {
+        return new ImageField(props.name, props.order, props.config).copyFields(props, true);
+    }
+}

package/dist/listgrid/components/fields/InlineMapField.d.ts

@@ -0,0 +1,40 @@
+import { FormField, FormFieldProps } from './abstract';
+import React from 'react';
+import { InlineMapConfig, MapKey } from '../../config/Config';
+import { FieldRenderParameters } from '../../config/EntityField';
+import { InlineMapPendingRef, KeyValue } from '../../ui';
+import { MinMaxLimit } from '../../form/Type';
+import { EntityForm } from '../../config/EntityForm';
+import { RenderType } from '../../config/Config';
+interface InlineMapFieldProps extends FormFieldProps {
+    config?: InlineMapConfig | undefined;
+}
+export declare class InlineMapField extends FormField<InlineMapField> {
+    config?: InlineMapConfig | undefined;
+    pendingRef: {
+        current: InlineMapPendingRef;
+    };
+    constructor(name: string, order: number, config?: InlineMapConfig);
+    isDirty(): boolean;
+    getSaveValue(entityForm: EntityForm, renderType?: RenderType): Promise<any>;
+    /**
+     * InlineMapField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * InlineMapField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): InlineMapField;
+    withKeys(keys?: MapKey[]): this;
+    useResultMap(): this;
+    useKeyValue(): this;
+    withLimit(limit?: MinMaxLimit): this;
+    withConfig(config?: InlineMapConfig): this;
+    /**
+     * Map 형태 또는 KeyValue[] 형태를 모두 지원한다.
+     * @param value
+     */
+    withDefaultValue(value: KeyValue[] | Map<string, string>): this;
+    static create(props: InlineMapFieldProps): InlineMapField;
+}
+export {};

package/dist/listgrid/components/fields/InlineMapField.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { InlineMap } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+export class InlineMapField extends FormField {
+    constructor(name, order, config) {
+        super(name, order, 'inlineMap');
+        this.pendingRef = { current: { value: undefined, modified: false } };
+        this.config = config;
+    }
+    isDirty() {
+        if (this.pendingRef.current.modified) {
+            return true;
+        }
+        return super.isDirty();
+    }
+    async getSaveValue(entityForm, renderType) {
+        if (this.pendingRef.current.modified) {
+            return this.pendingRef.current.value;
+        }
+        return super.getSaveValue(entityForm, renderType);
+    }
+    /**
+     * InlineMapField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            return (_jsx(InlineMap, { config: this.config, pendingRef: this.pendingRef, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * InlineMapField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        const instance = new InlineMapField(name, order, this.config);
+        instance.pendingRef = this.pendingRef;
+        return instance;
+    }
+    withKeys(keys) {
+        this.config = {
+            ...(keys !== undefined ? { keys } : {}),
+            ...(this.config?.limit !== undefined ? { limit: this.config.limit } : {}),
+            ...(this.config?.resultType !== undefined ? { resultType: this.config.resultType } : {}),
+        };
+        return this;
+    }
+    useResultMap() {
+        this.config = {
+            ...(this.config?.keys !== undefined ? { keys: this.config.keys } : {}),
+            ...(this.config?.limit !== undefined ? { limit: this.config.limit } : {}),
+            resultType: 'Map',
+        };
+        return this;
+    }
+    useKeyValue() {
+        this.config = {
+            ...(this.config?.keys !== undefined ? { keys: this.config.keys } : {}),
+            ...(this.config?.limit !== undefined ? { limit: this.config.limit } : {}),
+            resultType: 'KeyValue',
+        };
+        return this;
+    }
+    withLimit(limit) {
+        this.config = {
+            ...(this.config?.keys !== undefined ? { keys: this.config.keys } : {}),
+            ...(limit !== undefined ? { limit } : {}),
+            ...(this.config?.resultType !== undefined ? { resultType: this.config.resultType } : {}),
+        };
+        return this;
+    }
+    withConfig(config) {
+        this.config = config;
+        return this;
+    }
+    /**
+     * Map 형태 또는 KeyValue[] 형태를 모두 지원한다.
+     * @param value
+     */
+    withDefaultValue(value) {
+        return super.withDefaultValue(value);
+    }
+    static create(props) {
+        return new InlineMapField(props.name, props.order, props.config).copyFields(props, true);
+    }
+}

package/dist/listgrid/components/fields/LinkField.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { CheckButtonValidationField, CheckButtonValidationFieldProps, ViewListProps, ViewListResult } from './abstract';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+interface LinkFieldProps extends CheckButtonValidationFieldProps {
+}
+export declare class LinkField extends CheckButtonValidationField<LinkField> {
+    constructor(name: string, order: number);
+    /**
+     * LinkField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * LinkField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): LinkField;
+    /**
+     * LinkField 리스트 필터 렌더링 (원본 renderListFilter 로직 보존)
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * LinkField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    static create(props: LinkFieldProps): LinkField;
+}
+export {};

package/dist/listgrid/components/fields/LinkField.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CheckButtonValidationField, } from './abstract';
+import { TextInput } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { LinkFieldView } from './view/LinkFieldView';
+import { IconExternalLink } from '@tabler/icons-react';
+import { isBlank } from '../../utils/StringUtil';
+import { normalizeUrl } from '../../misc';
+export class LinkField extends CheckButtonValidationField {
+    constructor(name, order) {
+        super(name, order, 'text');
+    }
+    /**
+     * LinkField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        if (this.checkButtonValidation !== undefined) {
+            return super.renderCheckButtonValidationField(params);
+        }
+        return (async () => {
+            const inputParams = await getInputRendererParameters(this, params);
+            return (_jsx(LinkFieldView, { ...inputParams }));
+        })();
+    }
+    /**
+     * LinkField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new LinkField(name, order);
+    }
+    /**
+     * LinkField 리스트 필터 렌더링 (원본 renderListFilter 로직 보존)
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(TextInput, { name: `${this.name}_${params.entityForm.id}`, onChange: (value) => {
+                    params.onChange(value, 'LIKE');
+                }, value: params.value }));
+        })();
+    }
+    /**
+     * LinkField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    renderListItemInstance(props) {
+        const value = String(props.item[this.name] ?? '');
+        if (isBlank(value)) {
+            return Promise.resolve({ result: value });
+        }
+        // 링크가 존재하는 경우 클릭 가능한 링크로 렌더링
+        const linkElement = (_jsxs("div", { className: "rcm-link-cell", children: [_jsx("span", { className: "rcm-truncate", children: value }), !isBlank(value) && (_jsx("button", { type: "button", className: "rcm-link-cell-btn", onClick: (e) => {
+                        e.stopPropagation();
+                        window.open(normalizeUrl(value), '_blank');
+                    }, children: _jsx(IconExternalLink, { className: "rcm-link-cell-icon" }) }))] }));
+        return Promise.resolve({
+            result: linkElement,
+        });
+    }
+    static create(props) {
+        return new LinkField(props.name, props.order).copyFields(props, true);
+    }
+}

package/dist/listgrid/components/fields/ManyToOneField.d.ts

@@ -0,0 +1,80 @@
+import { AbstractManyToOneField, AbstractManyToOneFieldProps, CardViewConfig, SelectBoxViewConfig, UserListFieldProps, ViewListProps, ViewListResult, ViewRenderProps, ViewRenderResult } from './abstract';
+import React from 'react';
+import { ManyToOneConfig } from '../../config/Config';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+export interface ManyToOneFieldProps extends AbstractManyToOneFieldProps {
+}
+export declare class ManyToOneField extends AbstractManyToOneField<ManyToOneField> {
+    constructor(name: string, order: number, manyToOne: ManyToOneConfig);
+    /**
+     * ManyToOneField 핵심 렌더링 로직 (원본 render 로직 보존)
+     * useCardView가 활성화된 경우 CardManyToOneView로 렌더링
+     * useSelectBoxView가 활성화된 경우 SelectBoxManyToOneView로 렌더링
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * ManyToOneField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): ManyToOneField;
+    /**
+     * ManyToOneField 리스트 필터 렌더링
+     * multiFilter가 true이면 다중 선택 UI를 렌더링
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * ManyToOneField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     * 중첩 경로 지원: score.course.semester 같은 경로를 처리할 수 있음
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    /**
+     * ManyToOneField View 모드 렌더링 - 연관 엔티티의 이름/제목 표시
+     * 중첩 경로 지원: score.course.semester 같은 경로를 처리할 수 있음
+     * cardIcon이 설정된 경우 아이콘과 함께 표시
+     */
+    protected renderViewInstance(props: ViewRenderProps): Promise<ViewRenderResult>;
+    useListField(props?: number | UserListFieldProps): this;
+    static create(props: ManyToOneFieldProps): ManyToOneField;
+    withManyToOneConfig(config: ManyToOneConfig): this;
+    /**
+     * 카드뷰 렌더링 활성화
+     * EntityFormThemeProvider 없이도 CardManyToOneView로 렌더링 가능
+     *
+     * @example
+     * ```tsx
+     * ManyToOneField.create({
+     *   name: 'syllabus',
+     *   order: 1,
+     *   config: { entityForm: SyllabusEntityForm() }
+     * })
+     * .withCardView({
+     *   columns: 3,
+     *   mobileColumns: 2,
+     *   cardConfig: {
+     *     titleField: 'name',
+     *     descriptionField: (item) => `입학지원기간: ${formatDate(item.availableDate[0])}`,
+     *   }
+     * })
+     * ```
+     */
+    withCardView(config?: CardViewConfig): this;
+    /**
+     * 셀렉트박스뷰 렌더링 활성화
+     * ManyToOne 필드를 드롭다운 SelectBox로 렌더링
+     *
+     * @example
+     * ```tsx
+     * ManyToOneField.create({
+     *   name: 'country',
+     *   order: 1,
+     *   config: { entityForm: CountryEntityForm() }
+     * })
+     * .withSelectBoxView({
+     *   labelField: 'name',
+     *   placeholder: '국가를 선택하세요',
+     *   isSearchable: true,
+     * })
+     * ```
+     */
+    withSelectBoxView(config?: SelectBoxViewConfig): this;
+}
+export declare function getManyToOneEntityValue(name: string, value: any, config: ManyToOneConfig): Promise<any>;