@rchemist/listgrid 0.2.6

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

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MultipleOptionalField, renderListMultipleOptionalField, } from './abstract';
+import { TagsInput } from '../../ui';
+import { isEmpty } from '../../utils';
+// CSS module removed in Stage 8 (host app supplies styling)
+const classes = {};
+export class TagField extends MultipleOptionalField {
+    constructor(name, order, options, limit) {
+        super(name, order, 'tag', options, limit);
+    }
+    /**
+     * 태그 추가 시 실시간 검증 함수를 설정합니다.
+     * @param validation 검증 함수 (태그 값을 받아 TagValidationResult 반환)
+     */
+    withTagValidation(validation) {
+        this.tagValidation = validation;
+        return this;
+    }
+    /**
+     * TagField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        let tagData = undefined;
+        if (this.options !== undefined && !isEmpty(this.options)) {
+            tagData = this.options.map((option) => option.value);
+        }
+        const optionsFilter = (options, search) => {
+            const splittedSearch = search.toLowerCase().trim().split(' ');
+            return options.filter((option) => {
+                const words = option.toLowerCase().trim().split(' ');
+                return splittedSearch.every((searchWord) => words.some((word) => word.includes(searchWord)));
+            });
+        };
+        return (async () => {
+            return (_jsx(TagsInput, { size: 'md', readOnly: params.readonly, required: params.required, disabled: params.readonly, minTags: this.limit?.min, classNames: {
+                    root: classes.root,
+                    input: classes.input,
+                    wrapper: classes.wrapper,
+                }, maxTags: this.limit?.max, data: tagData, filter: optionsFilter, clearable: true, onChange: (value) => {
+                    params.onChange(value);
+                }, onValidateTag: this.tagValidation, value: await this.getDisplayValue(params.entityForm, params.entityForm.getRenderType()) }));
+        })();
+    }
+    /**
+     * TagField 핵심 리스트 필터 렌더링 로직 (기본 renderInstance 사용)
+     */
+    renderListFilterInstance(params) {
+        return this.renderInstance({
+            ...params,
+            required: false,
+            onChange: (value) => params.onChange(value),
+        });
+    }
+    /**
+     * TagField 핵심 리스트 아이템 렌더링 로직
+     */
+    renderListItemInstance(props) {
+        return renderListMultipleOptionalField(this, props);
+    }
+    /**
+     * TagField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        const instance = new TagField(name, order, this.options, this.limit);
+        instance.tagValidation = this.tagValidation;
+        return instance;
+    }
+    static create(props) {
+        const field = new TagField(props.name, props.order, props.options, props.limit).copyFields(props, true);
+        if (props.tagValidation) {
+            field.tagValidation = props.tagValidation;
+        }
+        return field;
+    }
+}

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

@@ -0,0 +1,35 @@
+import { ListableFormField, ListableFormFieldProps, ViewListProps, ViewListResult } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+import { Validation } from '../../validations/Validation';
+import { RenderType } from '../../config/Config';
+import { EntityForm } from '../../config/EntityForm';
+interface TelephoneNumberFieldProps extends ListableFormFieldProps {
+    validations?: Validation[];
+}
+export declare class TelephoneNumberField extends ListableFormField<TelephoneNumberField> {
+    validations?: Validation[];
+    constructor(name: string, order: number, validations?: Validation[]);
+    /**
+     * TelephoneNumberField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * TelephoneNumberField 표시값 가져오기 (하이픈 포맷팅)
+     */
+    getDisplayValue(entityForm: EntityForm, renderType?: RenderType): Promise<any>;
+    /**
+     * TelephoneNumberField 저장값 가져오기 (하이픈 제거)
+     */
+    getSaveValue(entityForm: EntityForm, renderType?: RenderType): Promise<any>;
+    /**
+     * TelephoneNumberField 리스트 아이템 렌더링 (하이픈 포맷팅)
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    /**
+     * TelephoneNumberField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): TelephoneNumberField;
+    static create(props: TelephoneNumberFieldProps): TelephoneNumberField;
+}
+export {};

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

@@ -0,0 +1,121 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ListableFormField, } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { useState, useEffect } from 'react';
+import { RegexValidation } from '../../validations/RegexValidation';
+import { readonlyClass } from '../../ui';
+import { formatPhoneNumber, removePhoneNumberHyphens } from '../../utils/PhoneUtil';
+/**
+ * 전화번호 입력 내부 컴포넌트 (TelephoneNumberField용)
+ * 입력 시 하이픈을 자동으로 제거하고, 표시 시 하이픈을 포맷팅합니다.
+ */
+const TelephoneNumberInput = ({ name, value, onChange, onError, readonly = false, placeHolder, regex, }) => {
+    // 표시용 값 (하이픈 포함)
+    const [displayValue, setDisplayValue] = useState('');
+    // 외부 value가 변경되면 displayValue 동기화 (하이픈 포맷팅)
+    useEffect(() => {
+        if (value) {
+            const formatted = formatPhoneNumber(value);
+            setDisplayValue(formatted);
+        }
+        else {
+            setDisplayValue('');
+        }
+    }, [value]);
+    const handleChange = (e) => {
+        const inputValue = e.target.value;
+        // 하이픈 제거 (숫자만 추출)
+        const digitsOnly = removePhoneNumberHyphens(inputValue);
+        // 최대 11자리로 제한
+        const truncated = digitsOnly.substring(0, 11);
+        // 표시용 값은 하이픈 포함 형식으로 포맷팅
+        const formatted = formatPhoneNumber(truncated);
+        setDisplayValue(formatted);
+        // 저장용 값은 하이픈 제거한 숫자만 전달 (입력 중에는 검증하지 않음)
+        onChange(truncated, false);
+    };
+    const handleBlur = () => {
+        const digitsOnly = removePhoneNumberHyphens(displayValue);
+        // blur 시에만 검증 (입력이 완료되었을 때)
+        if (regex && digitsOnly) {
+            const isValid = regex.pattern.test(digitsOnly);
+            if (!isValid) {
+                onError?.(regex.message);
+            }
+            else {
+                // 검증 통과 시 에러 초기화
+                onError?.('');
+            }
+        }
+        onChange(digitsOnly, true);
+    };
+    return (_jsx("input", { type: "text", className: readonlyClass(readonly, 'form-input'), id: name, value: displayValue, placeholder: placeHolder, disabled: readonly, onChange: handleChange, onBlur: handleBlur }));
+};
+export class TelephoneNumberField extends ListableFormField {
+    constructor(name, order, validations) {
+        super(name, order, 'text');
+        if (validations !== undefined) {
+            this.validations = validations;
+        }
+    }
+    /**
+     * TelephoneNumberField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            const inputParams = await getInputRendererParameters(this, params);
+            // validations에서 RegexValidation 찾기
+            let regex;
+            if (this.validations) {
+                const regexValidation = this.validations.find((v) => v instanceof RegexValidation);
+                if (regexValidation) {
+                    regex = {
+                        pattern: regexValidation.regex,
+                        message: regexValidation.message || '전화번호 형식이 올바르지 않습니다.',
+                    };
+                }
+            }
+            return (_jsx(TelephoneNumberInput, { name: inputParams.name, value: inputParams.value, onChange: inputParams.onChange, onError: inputParams.onError, readonly: inputParams.readonly, placeHolder: inputParams.placeHolder, regex: regex }));
+        })();
+    }
+    /**
+     * TelephoneNumberField 표시값 가져오기 (하이픈 포맷팅)
+     */
+    async getDisplayValue(entityForm, renderType) {
+        if (this.displayFunc) {
+            return this.displayFunc(entityForm, this, renderType);
+        }
+        const value = await this.getCurrentValue(renderType);
+        // 하이픈 포맷팅 적용
+        return formatPhoneNumber(value);
+    }
+    /**
+     * TelephoneNumberField 저장값 가져오기 (하이픈 제거)
+     */
+    async getSaveValue(entityForm, renderType) {
+        if (this.saveValue) {
+            return this.saveValue(entityForm, this, renderType);
+        }
+        const value = await this.getCurrentValue(renderType);
+        // 하이픈 제거한 숫자만 반환
+        return removePhoneNumberHyphens(value);
+    }
+    /**
+     * TelephoneNumberField 리스트 아이템 렌더링 (하이픈 포맷팅)
+     */
+    renderListItemInstance(props) {
+        const value = props.item[this.name];
+        const formatted = formatPhoneNumber(value);
+        return Promise.resolve({ result: formatted });
+    }
+    /**
+     * TelephoneNumberField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new TelephoneNumberField(name, order, this.validations);
+    }
+    static create(props) {
+        return new TelephoneNumberField(props.name, props.order, props.validations).copyFields(props, true);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { FormField, FormFieldProps } from './abstract';
+import React from 'react';
+import { RenderType } from '../../config/Config';
+import { FieldRenderParameters } from '../../config/EntityField';
+import { MinMaxLimit } from '../../form/Type';
+interface TextareaFieldProps extends FormFieldProps {
+    rows?: number | undefined;
+    limit?: MinMaxLimit | undefined;
+}
+export declare class TextareaField extends FormField<TextareaField> {
+    rows?: number | undefined;
+    limit?: MinMaxLimit | undefined;
+    constructor(name: string, order: number, rows?: number, limit?: MinMaxLimit);
+    getCurrentValue(renderType?: RenderType): Promise<any>;
+    /**
+     * TextareaField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * TextareaField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): TextareaField;
+    withRows(rows?: number): this;
+    withLimit(limit?: MinMaxLimit): this;
+    static create(props: TextareaFieldProps): TextareaField;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { Textarea } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+export class TextareaField extends FormField {
+    constructor(name, order, rows, limit) {
+        super(name, order, 'textarea');
+        this.rows = rows ?? 10; // 기본 10줄 표시
+        this.limit = limit;
+    }
+    async getCurrentValue(renderType) {
+        const renderTypeValue = renderType ?? 'create';
+        if (this.value !== undefined) {
+            return this.value?.current !== undefined
+                ? this.value?.current
+                : renderTypeValue === 'create'
+                    ? this.value?.default
+                    : this.value?.fetched;
+        }
+        return undefined;
+    }
+    /**
+     * TextareaField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            return (_jsx(Textarea, { rows: this.rows, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * TextareaField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new TextareaField(name, order, this.rows, this.limit);
+    }
+    withRows(rows) {
+        this.rows = rows;
+        return this;
+    }
+    withLimit(limit) {
+        this.limit = limit;
+        return this;
+    }
+    static create(props) {
+        return new TextareaField(props.name, props.order, props.rows, props.limit).copyFields(props, true);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { AbstractDateField, AbstractDateFieldProps } from './abstract';
+import React from 'react';
+import { FieldRenderParameters } from '../../config/EntityField';
+import { RenderType } from '../../config/Config';
+import { MinMaxStringLimit } from '../../form/Type';
+interface TimeFieldProps extends AbstractDateFieldProps {
+}
+export declare class TimeField extends AbstractDateField<TimeField> {
+    constructor(name: string, order: number, limit?: MinMaxStringLimit, range?: boolean);
+    getCurrentValue(renderType?: RenderType): Promise<any>;
+    /**
+     * TimeField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * TimeField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): TimeField;
+    static create(props: TimeFieldProps): TimeField;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AbstractDateField } from './abstract';
+import { isTrue } from '../../utils/BooleanUtil';
+import { getFormattedTime } from '../../misc';
+import { FlatPickrDateField } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+export class TimeField extends AbstractDateField {
+    constructor(name, order, limit, range) {
+        super(name, order, 'time', limit, range);
+    }
+    async getCurrentValue(renderType) {
+        const value = await super.getCurrentValue(renderType);
+        if (value === 'now') {
+            if (isTrue(this.range)) {
+                const now = getFormattedTime();
+                const after = getFormattedTime(new Date(), 12);
+                return [now, after];
+            }
+            return getFormattedTime();
+        }
+        return value;
+    }
+    /**
+     * TimeField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            return (_jsx(FlatPickrDateField, { type: 'time', limit: this.limit, range: this.range, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * TimeField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new TimeField(name, order, this.limit, this.range);
+    }
+    static create(props) {
+        return new TimeField(props.name, props.order, props.limit, props.range).copyFields(props, true);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { FormField, FormFieldProps } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+import { EntityForm } from '../../config/EntityForm';
+import { RenderType } from '../../config/Config';
+export interface XrefAvailableDateMappingFieldProps extends FormFieldProps {
+    entityForm: EntityForm;
+}
+export declare class XrefAvailableDateMappingField extends FormField<XrefAvailableDateMappingField> {
+    entityForm: EntityForm;
+    constructor(name: string, order: number, entityForm: EntityForm);
+    static create(props: XrefAvailableDateMappingFieldProps): XrefAvailableDateMappingField;
+    /**
+     * XrefAvailableDateMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null | undefined>;
+    /**
+     * XrefAvailableDateMappingField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): XrefAvailableDateMappingField;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+}

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

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { XrefAvailableDateMappingView, } from './view/XrefAvailableDateMappingView';
+import { isEmpty } from '../../utils';
+export class XrefAvailableDateMappingField extends FormField {
+    constructor(name, order, entityForm) {
+        super(name, order, 'xrefMapping');
+        this.entityForm = entityForm;
+        this.helpText = '이 정보를 변경한 후 반드시 저장 버튼을 눌러야 변경 사항이 반영됩니다.';
+    }
+    static create(props) {
+        return new XrefAvailableDateMappingField(props.name, props.order, props.entityForm).copyFields(props, true);
+    }
+    /**
+     * XrefAvailableDateMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        return (async () => {
+            const inputParams = await getInputRendererParameters(this, { ...params });
+            return (_jsx(XrefAvailableDateMappingView, { ...inputParams, entityForm: this.entityForm }));
+        })();
+    }
+    /**
+     * XrefAvailableDateMappingField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new XrefAvailableDateMappingField(name, order, this.entityForm);
+    }
+    // override
+    async isBlank(renderType = 'create') {
+        const value = await this.getCurrentValue(renderType);
+        if (value === undefined || value === null || value === '') {
+            return true;
+        }
+        const mappingValue = value;
+        return isEmpty(mappingValue.mapped);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { FormField, FormFieldProps } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+import { EntityForm } from '../../config/EntityForm';
+import { RenderType } from '../../config/Config';
+import { FilterItem } from '../../form/SearchForm';
+export interface XrefMappingFieldProps extends FormFieldProps {
+    supportPriority?: boolean | undefined;
+    excludeId?: string | undefined;
+    add?: boolean | undefined;
+    entityForm: EntityForm;
+    filters?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+}
+export declare class XrefMappingField extends FormField<XrefMappingField> {
+    entityForm: EntityForm;
+    supportPriority?: boolean | undefined;
+    excludeId?: string | undefined;
+    add?: boolean | undefined;
+    filters?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+    constructor({ name, order, entityForm, supportPriority, excludeId, add, filters, }: XrefMappingFieldProps);
+    /**
+     * XrefMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null | undefined>;
+    /**
+     * XrefMappingField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): XrefMappingField;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+}

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

@@ -0,0 +1,59 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { XrefMappingView } from './view/XrefMappingView';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { isTrue } from '../../utils/BooleanUtil';
+import { XrefPriorityMappingView } from './view/XrefPriorityMappingView';
+import { isEmpty } from '../../utils';
+export class XrefMappingField extends FormField {
+    constructor({ name, order, entityForm, supportPriority, excludeId, add, filters, }) {
+        super(name, order, 'xrefMapping');
+        this.entityForm = entityForm;
+        this.supportPriority = supportPriority;
+        this.helpText = '이 정보를 변경한 후 반드시 저장 버튼을 눌러야 변경 사항이 반영됩니다.';
+        this.excludeId = excludeId;
+        this.add = add ?? false;
+        this.filters = filters;
+    }
+    /**
+     * XrefMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        return (async () => {
+            const inputParams = await getInputRendererParameters(this, { ...params });
+            if (isTrue(this.supportPriority)) {
+                return (_jsx(XrefPriorityMappingView, { ...inputParams, parentEntityForm: params.entityForm, entityForm: this.entityForm, excludeId: this.excludeId, add: this.add, filters: this.filters }));
+            }
+            return (_jsx(XrefMappingView, { ...inputParams, parentEntityForm: params.entityForm, entityForm: this.entityForm, excludeId: this.excludeId, add: this.add, filters: this.filters }));
+        })();
+    }
+    /**
+     * XrefMappingField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new XrefMappingField({
+            name,
+            order,
+            entityForm: this.entityForm,
+            supportPriority: this.supportPriority,
+            excludeId: this.excludeId,
+            add: this.add,
+            filters: this.filters,
+        });
+    }
+    // override
+    async isBlank(renderType = 'create') {
+        const value = await this.getCurrentValue(renderType);
+        if (value === undefined || value === null || value === '') {
+            return true;
+        }
+        if (isTrue(this.supportPriority)) {
+            const mappingValue = value;
+            return isEmpty(mappingValue.mapped);
+        }
+        else {
+            const mappingValue = value;
+            return isEmpty(mappingValue.mapped);
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import { FormField, FormFieldProps } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+import { EntityForm } from '../../config/EntityForm';
+import { RenderType } from '../../config/Config';
+import { FilterItem } from '../../form/SearchForm';
+export interface XrefPreferMappingFieldProps extends FormFieldProps {
+    entityForm: EntityForm;
+    showPreferred?: boolean | undefined;
+    filters?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+    preferredLabel?: string | undefined;
+}
+export declare class XrefPreferMappingField extends FormField<XrefPreferMappingField> {
+    entityForm: EntityForm;
+    showPreferred?: boolean | undefined;
+    filters?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+    preferredLabel?: string | undefined;
+    constructor(props: XrefPreferMappingFieldProps);
+    static create(props: XrefPreferMappingFieldProps): XrefPreferMappingField;
+    /**
+     * XrefPreferMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null | undefined>;
+    /**
+     * XrefPreferMappingField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): XrefPreferMappingField;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+    withPreferredLabel(preferredLabel: string): XrefPreferMappingField;
+}

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

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormField } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { XrefPreferMappingView } from './view/XrefPreferMappingView';
+import { isEmpty } from '../../utils';
+export class XrefPreferMappingField extends FormField {
+    constructor(props) {
+        super(props.name, props.order, 'xrefMapping');
+        this.entityForm = props.entityForm;
+        this.helpText = '이 정보를 변경한 후 반드시 저장 버튼을 눌러야 변경 사항이 반영됩니다.';
+        this.showPreferred = props.showPreferred;
+        this.filters = props.filters;
+        this.preferredLabel = props.preferredLabel;
+    }
+    static create(props) {
+        return new XrefPreferMappingField(props).copyFields(props, true);
+    }
+    /**
+     * XrefPreferMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        return (async () => {
+            const inputParams = await getInputRendererParameters(this, { ...params });
+            return (_jsx(XrefPreferMappingView, { ...inputParams, showPreferred: this.showPreferred, entityForm: this.entityForm, parentEntityForm: params.entityForm, filters: this.filters, preferredLabel: this.preferredLabel }));
+        })();
+    }
+    /**
+     * XrefPreferMappingField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new XrefPreferMappingField({
+            name,
+            order,
+            entityForm: this.entityForm,
+            showPreferred: this.showPreferred,
+            filters: this.filters,
+            preferredLabel: this.preferredLabel,
+        });
+    }
+    // override
+    async isBlank(renderType = 'create') {
+        const value = await this.getCurrentValue(renderType);
+        if (value === undefined || value === null || value === '') {
+            return true;
+        }
+        const mappingValue = value;
+        return isEmpty(mappingValue.mapped);
+    }
+    withPreferredLabel(preferredLabel) {
+        this.preferredLabel = preferredLabel;
+        return this;
+    }
+}

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

@@ -0,0 +1,33 @@
+import { FormField, FormFieldProps } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+import { EntityForm } from '../../config/EntityForm';
+import { RenderType } from '../../config/Config';
+import { FilterItem } from '../../form/SearchForm';
+interface XrefPriceAdditionalProps {
+    entityForm: EntityForm;
+    initPrice: (entityForm: EntityForm, rowValue: any) => Promise<void>;
+    priceHelpText?: string | undefined;
+    filterItems?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+}
+export interface XrefPriceMappingFieldProps extends FormFieldProps, XrefPriceAdditionalProps {
+}
+export declare class XrefPriceMappingField extends FormField<XrefPriceMappingField> {
+    entityForm: EntityForm;
+    initPrice: (entityForm: EntityForm, rowValue: any) => Promise<void>;
+    priceHelpText?: string | undefined;
+    filterItems?: FilterItem[] | ((entityForm: EntityForm, parentEntityForm?: EntityForm) => Promise<FilterItem[]>) | undefined;
+    constructor(name: string, order: number, props: XrefPriceAdditionalProps);
+    static create(props: XrefPriceMappingFieldProps): XrefPriceMappingField;
+    /**
+     * XrefPriceMappingField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null | undefined>;
+    /**
+     * XrefPriceMappingField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): XrefPriceMappingField;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+    withFilterItem(filterItems: FilterItem[]): this;
+}
+export {};