@rchemist/listgrid 0.2.6

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

@@ -0,0 +1,216 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ListableFormField, } from './abstract';
+import { NumberInput } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { formatPrice } from '../../misc';
+import { IconCoin, IconHash } from '@tabler/icons-react';
+import { NumberFilter } from './filter/NumberFilter';
+import { ValidateResult } from '../../validations/Validation';
+export class NumberField extends ListableFormField {
+    withMin(min) {
+        if (this.limit) {
+            if (min !== undefined)
+                this.limit.min = min;
+            else
+                delete this.limit.min;
+        }
+        else {
+            const newLimit = {};
+            if (min !== undefined)
+                newLimit.min = min;
+            this.limit = newLimit;
+        }
+        return this;
+    }
+    withMax(max) {
+        if (this.limit) {
+            if (max !== undefined)
+                this.limit.max = max;
+            else
+                delete this.limit.max;
+        }
+        else {
+            const newLimit = {};
+            if (max !== undefined)
+                newLimit.max = max;
+            this.limit = newLimit;
+        }
+        return this;
+    }
+    withLimit(limit) {
+        if (limit !== undefined)
+            this.limit = limit;
+        else
+            delete this.limit;
+        return this;
+    }
+    withCurrency(currency) {
+        if (currency !== undefined)
+            this.currency = currency;
+        else
+            delete this.currency;
+        return this;
+    }
+    withDouble(double) {
+        if (double !== undefined)
+            this.double = double;
+        else
+            delete this.double;
+        return this;
+    }
+    constructor(name, order, props) {
+        super(name, order, 'number');
+        if (props?.limit !== undefined)
+            this.limit = props.limit;
+        if (props?.currency !== undefined)
+            this.currency = props.currency;
+        if (props?.double !== undefined)
+            this.double = props.double;
+    }
+    /**
+     * NumberField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            return (_jsx(NumberInput, { limit: this.limit, currency: this.currency, double: this.double, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * NumberField 핵심 리스트 필터 렌더링 로직
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(NumberFilter, { onChange: (queryConditionType, value) => {
+                    params.onChange(value, queryConditionType);
+                }, onRemove: () => {
+                    params.onChange('');
+                } }));
+        })();
+    }
+    /**
+     * NumberField 핵심 리스트 아이템 렌더링 로직
+     */
+    renderListItemInstance(props) {
+        if (props.item[this.name] !== undefined) {
+            const numberValue = props.item[this.name];
+            return Promise.resolve({ result: formatPrice(numberValue) });
+        }
+        // 기본 값 표시
+        const value = String(props.item[this.name] ?? '');
+        return Promise.resolve({ result: value });
+    }
+    /**
+     * NumberField View 모드 렌더링 - 숫자 포맷팅
+     * compact 모드: 아이콘 없이 깔끔한 텍스트만 표시
+     * 일반 모드: 아이콘 + 포맷된 숫자 표시
+     */
+    async renderViewInstance(props) {
+        const value = props.item[this.name];
+        // null, undefined, 빈 문자열 처리
+        if (value === null || value === undefined || value === '') {
+            return { result: null };
+        }
+        const numberValue = Number(value);
+        if (isNaN(numberValue)) {
+            return { result: String(value) };
+        }
+        // formatPrice 함수를 사용하여 천단위 구분자 적용
+        const formattedValue = formatPrice(numberValue);
+        // currency 설정이 있으면 통화 기호 추가
+        if (this.currency) {
+            const currencyCode = this.currency.currencyCode ?? 'KRW';
+            const currencySymbol = currencyCode === 'KRW'
+                ? '원'
+                : currencyCode === 'USD'
+                    ? '$'
+                    : currencyCode === 'EUR'
+                        ? '€'
+                        : currencyCode === 'JPY'
+                            ? '¥'
+                            : currencyCode === 'GBP'
+                                ? '£'
+                                : '';
+            // position에 따라 기호 위치 결정
+            const displayText = this.currency.position === 'after' || currencyCode === 'KRW'
+                ? `${formattedValue}${currencySymbol}`
+                : `${currencySymbol}${formattedValue}`;
+            // compact 모드: 텍스트만 반환
+            if (props.compact) {
+                return { result: displayText };
+            }
+            // 일반 모드: 아이콘 + 텍스트
+            const IconComponent = this.cardIcon || IconCoin;
+            const frameColor = this.cardIcon ? undefined : 'success';
+            return {
+                result: (_jsxs("span", { className: "rcm-bool-wrap", children: [_jsx("span", { className: "rcm-icon-frame", "data-color": frameColor, children: _jsx(IconComponent, { className: "rcm-icon", "data-size": "sm", stroke: 1.75 }) }), _jsx("span", { className: "rcm-num-value rcm-num-value-emphasis", children: displayText })] })),
+            };
+        }
+        // compact 모드: 텍스트만 반환
+        if (props.compact) {
+            return { result: formattedValue };
+        }
+        // 일반 모드: 아이콘 + 텍스트
+        const IconComponent = this.cardIcon || IconHash;
+        const frameColor = this.cardIcon ? undefined : 'info';
+        return {
+            result: (_jsxs("span", { className: "rcm-bool-wrap", children: [_jsx("span", { className: "rcm-icon-frame", "data-color": frameColor, children: _jsx(IconComponent, { className: "rcm-icon", "data-size": "sm", stroke: 1.75 }) }), _jsx("span", { className: "rcm-num-value", children: formattedValue })] })),
+        };
+    }
+    /**
+     * NumberField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        const ctorProps = {};
+        if (this.limit !== undefined)
+            ctorProps.limit = this.limit;
+        if (this.currency !== undefined)
+            ctorProps.currency = this.currency;
+        if (this.double !== undefined)
+            ctorProps.double = this.double;
+        return new NumberField(name, order, ctorProps);
+    }
+    static create(props) {
+        const ctorProps = {};
+        if (props.limit !== undefined)
+            ctorProps.limit = props.limit;
+        if (props.currency !== undefined)
+            ctorProps.currency = props.currency;
+        if (props.double !== undefined)
+            ctorProps.double = props.double;
+        return new NumberField(props.name, props.order, ctorProps).copyFields(props, true);
+    }
+    async validate(entityForm, session) {
+        // hidden 또는 readonly인 경우 min/max 검증 건너뛰기
+        if ((await this.isHidden({ entityForm, session })) ||
+            (await this.isReadonly({ entityForm, session }))) {
+            return ValidateResult.success();
+        }
+        const result = await super.validate(entityForm, session);
+        // result 는 ValidateResult 단수거나 ValidateResult[] 이다.
+        // ValidateResult 의 error 여부를 판단해 최종으로 에러가 안 났으면 NumberField 자체의 기본 검증을 처리한다.
+        // 여기서 기본 검증이란 min, max 값 검증을 의미한다.
+        if (!this.hasError(result)) {
+            if (this.limit) {
+                const value = await entityForm.getValue(this.name);
+                if (value !== undefined && value !== '') {
+                    const numberValue = Number(value);
+                    if (this.limit.min !== undefined && numberValue < this.limit.min) {
+                        return ValidateResult.fail(`${this.getLabel()} 값은 ${this.limit.min} 이상이어야 합니다.`);
+                    }
+                    if (this.limit.max !== undefined && numberValue > this.limit.max) {
+                        return ValidateResult.fail(`${this.getLabel()} 값은 ${this.limit.max} 이하이어야 합니다.`);
+                    }
+                }
+            }
+            return ValidateResult.success();
+        }
+        return result;
+    }
+    hasError(result) {
+        if (Array.isArray(result)) {
+            return result.some((r) => r.hasError());
+        }
+        return result.hasError();
+    }
+}

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Validation } from '../../validations/Validation';
+import { FormField, FormFieldProps } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import { PasswordStrength } from '../../ui';
+interface PasswordFieldProps extends FormFieldProps {
+    strength?: PasswordStrength;
+}
+export declare class PasswordField extends FormField<PasswordField> {
+    strength?: PasswordStrength;
+    constructor(name: string, order: number, validations?: Validation[], strength?: PasswordStrength);
+    /**
+     * PasswordField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * PasswordField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): PasswordField;
+    withStrength(strength?: PasswordStrength): this;
+    static create(props: PasswordFieldProps): PasswordField;
+}
+export {};

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

@@ -0,0 +1,70 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { PasswordValidation } from '../../validations/PasswordValidation';
+import { FormField } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { PasswordStrengthView } from '../../ui';
+import { TextInput } from '../../ui';
+import { RegexValidation } from '../../validations/RegexValidation';
+export class PasswordField extends FormField {
+    constructor(name, order, validations, strength) {
+        super(name, order, 'password');
+        if (validations) {
+            this.validations = [...validations];
+        }
+        else {
+            this.validations = [new PasswordValidation()];
+        }
+        if (strength) {
+            this.strength = strength;
+            if (strength.regex) {
+                const newValidations = [];
+                for (const regex of strength.regex) {
+                    newValidations.push(new RegexValidation('passwordStrength-' + name, regex.pattern, regex.error));
+                }
+                this.validations = [...this.validations, ...newValidations];
+            }
+        }
+    }
+    /**
+     * PasswordField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        if (this.strength === undefined) {
+            return (async () => {
+                return _jsx(TextInput, { ...await getInputRendererParameters(this, params) });
+            })();
+        }
+        return (async () => {
+            return (_jsx(PasswordStrengthView, { strength: this.strength, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * PasswordField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new PasswordField(name, order).withStrength(this.strength);
+    }
+    withStrength(strength) {
+        this.strength = strength;
+        // strength 필드를 사용하는 경우 기본 validation 을 사용하지 않는다.
+        if (strength !== undefined && this.validations !== undefined && this.validations.length > 0) {
+            const newValidations = [];
+            for (const validation of this.validations) {
+                if (validation.id !== 'PasswordValidation') {
+                    newValidations.push({ ...validation });
+                }
+            }
+            // Add RegexValidation from strength.regex
+            if (strength.regex) {
+                for (const regex of strength.regex) {
+                    newValidations.push(new RegexValidation('passwordStrength-' + this.name, regex.pattern, regex.error));
+                }
+            }
+            this.validations = newValidations;
+        }
+        return this;
+    }
+    static create(props) {
+        return new PasswordField(props.name, props.order, props.validations, props.strength).copyFields(props, true);
+    }
+}

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

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

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

@@ -0,0 +1,91 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ListableFormField, } from './abstract';
+import { PhoneNumberValidation } from '../../validations/PhoneNumberValidation';
+import { RegexValidation } from '../../validations/RegexValidation';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { formatPhoneNumber, removePhoneNumberHyphens } from '../../utils/PhoneUtil';
+import { PhoneNumberFieldView } from './view/PhoneNumberFieldView';
+import { PhoneNumberListView } from './view/PhoneNumberListView';
+export class PhoneNumberField extends ListableFormField {
+    constructor(name, order, validations, enableSms) {
+        super(name, order, 'phone');
+        this.validations = validations ? [...validations] : [new PhoneNumberValidation()];
+        this.helpText = '숫자만 10 ~ 11 자리 사이로 입력해 주세요';
+        this.enableSms = enableSms ?? false;
+    }
+    /**
+     * Enable SMS functionality
+     */
+    withSms(enabled = true) {
+        this.enableSms = enabled;
+        return this;
+    }
+    /**
+     * PhoneNumberField 핵심 렌더링 로직
+     */
+    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(PhoneNumberFieldView, { name: inputParams.name, value: inputParams.value, onChange: inputParams.onChange, onError: inputParams.onError, readonly: inputParams.readonly, placeHolder: inputParams.placeHolder, regex: regex, enableSms: this.enableSms, session: params.entityForm.session, renderType: params.entityForm.getRenderType() }));
+        })();
+    }
+    /**
+     * PhoneNumberField 표시값 가져오기 (하이픈 포맷팅)
+     */
+    async getDisplayValue(entityForm, renderType) {
+        if (this.displayFunc) {
+            return this.displayFunc(entityForm, this, renderType);
+        }
+        const value = await this.getCurrentValue(renderType);
+        // 하이픈 포맷팅 적용
+        return formatPhoneNumber(value);
+    }
+    /**
+     * PhoneNumberField 저장값 가져오기 (하이픈 제거)
+     */
+    async getSaveValue(entityForm, renderType) {
+        if (this.saveValue) {
+            return this.saveValue(entityForm, this, renderType);
+        }
+        const value = await this.getCurrentValue(renderType);
+        // 하이픈 제거한 숫자만 반환
+        return removePhoneNumberHyphens(value);
+    }
+    /**
+     * PhoneNumberField 리스트 아이템 렌더링 (하이픈 포맷팅 + SMS 기능)
+     */
+    renderListItemInstance(props) {
+        const value = props.item[this.name];
+        const formatted = formatPhoneNumber(value);
+        // If SMS is enabled and we have a value, use PhoneNumberListView
+        if (this.enableSms && value) {
+            return Promise.resolve({
+                result: (_jsx(PhoneNumberListView, { phoneNumber: value, formattedValue: formatted, enableSms: this.enableSms, session: props.entityForm.session })),
+                linkOnCell: true, // Prevent row click from triggering when clicking the dropdown
+            });
+        }
+        return Promise.resolve({ result: formatted });
+    }
+    /**
+     * PhoneNumberField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new PhoneNumberField(name, order, this.validations, this.enableSms);
+    }
+    static create(props) {
+        const field = new PhoneNumberField(props.name, props.order, props.validations, props.enableSms);
+        return field.copyFields(props, true);
+    }
+}

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

@@ -0,0 +1,68 @@
+import { FormField } from './abstract';
+import { StringField } from './StringField';
+import { TextareaField } from './TextareaField';
+import { BooleanField } from './BooleanField';
+import { NumberField } from './NumberField';
+import { DatetimeField } from './DatetimeField';
+import { MarkdownField } from './MarkdownField';
+import { EntityForm } from '../../config/EntityForm';
+import { AddFieldItemProps } from '../../config/EntityFormTypes';
+import { SelectOption } from '../../form/Type';
+import { SelectField } from './SelectField';
+import { ReactNode } from 'react';
+export declare const SeoMetadataFields: FormField<any>[];
+export interface CommonFieldProps {
+    label?: string;
+    order?: number;
+    name?: string;
+}
+export declare const AliasField: (props: CheckDuplicatedFieldProps) => StringField;
+export declare const ExternalIdField: (props: ExternalIdFieldProps) => StringField;
+export declare const NameField: (props?: CommonFieldProps) => StringField;
+export declare const LabelField: (props?: CommonFieldProps) => StringField;
+export declare const DescriptionField: (props?: CommonFieldProps) => MarkdownField;
+export declare const TitleField: (props?: CommonFieldProps) => StringField;
+export declare const ContentField: (props?: CommonFieldProps) => MarkdownField;
+interface CheckDuplicatedFieldProps extends CommonFieldProps {
+    fetchUrl: string;
+    entity: string;
+    entityName: string;
+}
+interface ExternalIdFieldProps extends CommonFieldProps {
+    fetchUrl: string;
+}
+export declare const SlugField: (props: CheckDuplicatedFieldProps) => StringField;
+interface AvailableDatetimeFieldProps extends CommonFieldProps {
+    fieldName?: {
+        availableAt: string;
+        availableUntil: string;
+    };
+    fieldLabel?: {
+        availableAt: string;
+        availableUntil: string;
+    };
+}
+export declare const AvailableDatetimeFields: (target: string, props?: AvailableDatetimeFieldProps) => DatetimeField[];
+export declare const StatusDateAndRevisionPreset: (useUpdatedAt?: boolean, useRevision?: boolean) => AddFieldItemProps;
+export declare const StatusCreatedAtFieldPreset: AddFieldItemProps;
+export declare const StatusCreatedAndUpdatedAtFieldPreset: AddFieldItemProps;
+export declare const XrefAtFieldPreset: AddFieldItemProps;
+export declare const DeviceTypes: SelectOption[];
+export declare const DeviceTypeField: (props?: CommonFieldProps) => SelectField;
+export declare const HiddenField: (props?: CommonFieldProps) => BooleanField;
+export declare const PriorityField: (props?: CommonFieldProps) => NumberField;
+interface ActiveFieldProps extends CommonFieldProps {
+    defaultValue?: boolean;
+}
+export declare const ActiveField: (props?: ActiveFieldProps) => BooleanField;
+export declare const MarketingField: (props?: CommonFieldProps) => (StringField | TextareaField)[];
+export declare const TooltipDiv: (props: {
+    children: ReactNode | ReactNode[];
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const PublishStatusTypes: SelectOption[];
+export declare const DraftPublishStatusTypes: SelectOption[];
+export declare const PublishedPublishStatusTypes: SelectOption[];
+export declare const DiscardedPublishStatusTypes: SelectOption[];
+export declare const PublishStatusFieldPreset: AddFieldItemProps;
+export declare function applyPublishStatusEntityForm(entityForm: EntityForm, ...readonlyOnPublishedFields: string[]): EntityForm;
+export {};