@rchemist/listgrid 0.2.6

package/dist/listgrid/utils/lazy.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy } from 'react';
+// intentional: generic component loading mirrors next/dynamic ComponentType<any> contract
+export function lazyImport(loader, options = {}) {
+    const Lazy = lazy(loader);
+    const fallback = options.loading ? options.loading() : null;
+    const Wrapped = (props) => (_jsx(Suspense, { fallback: fallback, children: _jsx(Lazy, { ...props }) }));
+    Wrapped.displayName = 'LazyImport';
+    return Wrapped;
+}
+// Named as `dynamic` so call sites can `import { dynamic } from '.../utils/lazy'`
+// and preserve the original `dynamic(...)` call shape.
+export { lazyImport as dynamic };

package/dist/listgrid/utils/simpleCrypt.d.ts

@@ -0,0 +1,4 @@
+export declare function encrypt(input: string, compress?: boolean): string;
+export declare function decrypt(ciphertext: string, decompress?: boolean): string;
+export declare function hash(...input: unknown[]): string;
+export declare function generateUUID(): string;

package/dist/listgrid/utils/simpleCrypt.js

@@ -0,0 +1,79 @@
+import * as CryptoJS from 'crypto-js';
+import { isTrue } from './BooleanUtil';
+import { stringify } from './jsonUtils';
+import { getRuntimeConfig } from '../config/RuntimeConfig';
+// Lazy-resolved: call getRuntimeConfig() at use time so host-side
+// configureRuntime({ cryptKey: ... }) can run after module import.
+function secretKey() {
+    return getRuntimeConfig().cryptKey || 'rcm-token-secret';
+}
+export function encrypt(input, compress) {
+    let value = CryptoJS.AES.encrypt(input, secretKey()).toString();
+    if (isTrue(compress)) {
+    }
+    return value;
+}
+export function decrypt(ciphertext, decompress) {
+    let text = ciphertext;
+    if (isTrue(decompress)) {
+    }
+    const bytes = CryptoJS.AES.decrypt(text, secretKey());
+    return bytes.toString(CryptoJS.enc.Utf8);
+}
+export function hash(...input) {
+    let inputs = '';
+    const normalized = [];
+    for (let i = 0; i < input.length; i++) {
+        let s;
+        if (input[i] === undefined || input[i] === null)
+            s = '_NULL_';
+        else if (typeof input[i] === 'object')
+            s = stringify(input[i]);
+        else
+            s = String(input[i]);
+        normalized.push(s);
+        inputs += s.trim();
+    }
+    return CryptoJS.SHA256(inputs).toString();
+}
+export // Generate a UUID v4
+ function generateUUID() {
+    const bytes = CryptoJS.lib.WordArray.random(16).words;
+    // Convert WordArray to byte array
+    const byteArray = [];
+    for (let i = 0; i < bytes.length; i++) {
+        const word = bytes[i];
+        byteArray.push((word >> 24) & 0xff);
+        byteArray.push((word >> 16) & 0xff);
+        byteArray.push((word >> 8) & 0xff);
+        byteArray.push(word & 0xff);
+    }
+    // Set the version to 4 (0100)
+    byteArray[6] = (byteArray[6] & 0x0f) | 0x40;
+    // Set the variant to 8, 9, A, or B (10xx)
+    byteArray[8] = (byteArray[8] & 0x3f) | 0x80;
+    const byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+        byteToHex[i] = (i + 0x100).toString(16).substring(1);
+    }
+    return (byteToHex[byteArray[0]] +
+        byteToHex[byteArray[1]] +
+        byteToHex[byteArray[2]] +
+        byteToHex[byteArray[3]] +
+        '-' +
+        byteToHex[byteArray[4]] +
+        byteToHex[byteArray[5]] +
+        '-' +
+        byteToHex[byteArray[6]] +
+        byteToHex[byteArray[7]] +
+        '-' +
+        byteToHex[byteArray[8]] +
+        byteToHex[byteArray[9]] +
+        '-' +
+        byteToHex[byteArray[10]] +
+        byteToHex[byteArray[11]] +
+        byteToHex[byteArray[12]] +
+        byteToHex[byteArray[13]] +
+        byteToHex[byteArray[14]] +
+        byteToHex[byteArray[15]]);
+}

package/dist/listgrid/validations/CustomValidation.d.ts

@@ -0,0 +1,8 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class CustomValidation extends ValidationItem {
+    validateFunction: (entityForm: EntityForm, value: FieldValue, message?: string) => Promise<ValidateResult>;
+    constructor(id: string, validateFunction: (entityForm: EntityForm, value: FieldValue, message?: string) => Promise<ValidateResult>, errorMessage?: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/CustomValidation.js

@@ -0,0 +1,10 @@
+import { ValidationItem } from '../validations/Validation';
+export class CustomValidation extends ValidationItem {
+    constructor(id, validateFunction, errorMessage) {
+        super(id, errorMessage);
+        this.validateFunction = validateFunction;
+    }
+    validate(entityForm, value, message) {
+        return this.validateFunction(entityForm, value, message);
+    }
+}

package/dist/listgrid/validations/EmailValidation.d.ts

@@ -0,0 +1,4 @@
+import { RegexValidation } from '../validations/RegexValidation';
+export declare class EmailValidation extends RegexValidation {
+    constructor(id?: string, regex?: RegExp, message?: string);
+}

package/dist/listgrid/validations/EmailValidation.js

@@ -0,0 +1,7 @@
+import { RegexValidation } from '../validations/RegexValidation';
+import { RegexEmailAddress } from '../misc';
+export class EmailValidation extends RegexValidation {
+    constructor(id, regex, message) {
+        super(id ?? 'EmailValidation', regex ?? RegexEmailAddress, message ?? '이메일 형식으로 입력해주세요');
+    }
+}

package/dist/listgrid/validations/IpAddressValidation.d.ts

@@ -0,0 +1,26 @@
+import { ValidateResult, ValidationItem } from './Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+import { TagValidationResult } from '../form/TagsInput/types';
+export declare const RegexAllowedIpAddr: RegExp;
+/**
+ * IP 주소 형식 검증 클래스
+ *
+ * 허용 형식:
+ * - XXX.XXX.XXX.XXX (일반 IP 주소, 예: 192.168.1.1)
+ * - XXX.XXX.XXX.* (와일드카드, 예: 192.168.1.*)
+ * - XXX.XXX.* (와일드카드, 예: 192.168.*)
+ * - XXX.* (와일드카드, 예: 192.*)
+ */
+export declare class IpAddressValidation extends ValidationItem {
+    constructor(id?: string, message?: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}
+/**
+ * TagField의 withTagValidation에서 사용할 IP 주소 검증 함수
+ * 각 태그가 추가될 때 실시간으로 검증합니다.
+ *
+ * @param value - 검증할 IP 주소 값
+ * @returns TagValidationResult
+ */
+export declare function validateIpAddressTag(value: string): TagValidationResult;

package/dist/listgrid/validations/IpAddressValidation.js

@@ -0,0 +1,57 @@
+import { ValidationItem } from './Validation';
+// IP 주소 검증 정규식: XXX.XXX.XXX.XXX, XXX.XXX.XXX.*, XXX.XXX.*, XXX.*
+const ipSegment = '(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])';
+export const RegexAllowedIpAddr = new RegExp(`^(${ipSegment}\\.${ipSegment}\\.${ipSegment}\\.${ipSegment}|` +
+    `${ipSegment}\\.${ipSegment}\\.${ipSegment}\\.\\*|` +
+    `${ipSegment}\\.${ipSegment}\\.\\*|` +
+    `${ipSegment}\\.\\*)$`);
+/**
+ * IP 주소 형식 검증 클래스
+ *
+ * 허용 형식:
+ * - XXX.XXX.XXX.XXX (일반 IP 주소, 예: 192.168.1.1)
+ * - XXX.XXX.XXX.* (와일드카드, 예: 192.168.1.*)
+ * - XXX.XXX.* (와일드카드, 예: 192.168.*)
+ * - XXX.* (와일드카드, 예: 192.*)
+ */
+export class IpAddressValidation extends ValidationItem {
+    constructor(id = 'ip-address-format', message) {
+        super(id, message ??
+            '유효하지 않은 IP 주소 형식입니다. 허용 형식: XXX.XXX.XXX.XXX, XXX.XXX.XXX.*, XXX.XXX.*, XXX.*');
+    }
+    validate(entityForm, value, message) {
+        const ipAddresses = value?.current;
+        if (!ipAddresses || ipAddresses.length === 0) {
+            return Promise.resolve(this.returnValidateResult(false, message));
+        }
+        for (const ip of ipAddresses) {
+            if (!ip || ip.trim() === '')
+                continue;
+            if (!RegexAllowedIpAddr.test(ip.trim())) {
+                const errorMessage = `유효하지 않은 IP 주소 형식입니다: ${ip}. 허용 형식: 숫자 XXX.XXX.XXX.XXX, XXX.XXX.XXX.*, XXX.XXX.*, XXX.*`;
+                return Promise.resolve(this.returnValidateResult(true, errorMessage));
+            }
+        }
+        return Promise.resolve(this.returnValidateResult(false, message));
+    }
+}
+/**
+ * TagField의 withTagValidation에서 사용할 IP 주소 검증 함수
+ * 각 태그가 추가될 때 실시간으로 검증합니다.
+ *
+ * @param value - 검증할 IP 주소 값
+ * @returns TagValidationResult
+ */
+export function validateIpAddressTag(value) {
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return { valid: true };
+    }
+    if (RegexAllowedIpAddr.test(trimmedValue)) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        message: `유효하지 않은 IP 주소 형식입니다: ${value}. 허용 형식: XXX.XXX.XXX.XXX, XXX.XXX.XXX.*, XXX.XXX.*, XXX.*`,
+    };
+}

package/dist/listgrid/validations/MinMaxNumberValidation.d.ts

@@ -0,0 +1,14 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class MinMaxNumberValidation extends ValidationItem {
+    limit: {
+        min?: number;
+        max?: number;
+    };
+    constructor(id: string | undefined, limit: {
+        min?: number;
+        max?: number;
+    }, message?: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/MinMaxNumberValidation.js

@@ -0,0 +1,28 @@
+import { ValidationItem } from '../validations/Validation';
+export class MinMaxNumberValidation extends ValidationItem {
+    constructor(id, limit, message) {
+        super(id ?? 'MinMaxNumberValidation', message);
+        this.limit = limit;
+    }
+    validate(entityForm, value, message) {
+        const numberValue = this.getValueAsNumber(entityForm, value);
+        if (isNaN(numberValue)) {
+            return Promise.resolve(this.returnValidateResult(true, message));
+        }
+        let error = false;
+        if (this.limit.min || this.limit.max) {
+            if (numberValue === undefined) {
+                error = true;
+            }
+            else {
+                if (this.limit.min && numberValue < this.limit.min) {
+                    error = true;
+                }
+                else if (this.limit.max && numberValue > this.limit.max) {
+                    error = true;
+                }
+            }
+        }
+        return Promise.resolve(this.returnValidateResult(error, message));
+    }
+}

package/dist/listgrid/validations/PasswordValidation.d.ts

@@ -0,0 +1,4 @@
+import { RegexValidation } from '../validations/RegexValidation';
+export declare class PasswordValidation extends RegexValidation {
+    constructor(id?: string, regex?: RegExp, message?: string);
+}

package/dist/listgrid/validations/PasswordValidation.js

@@ -0,0 +1,7 @@
+import { RegexPasswordNormal } from '../misc';
+import { RegexValidation } from '../validations/RegexValidation';
+export class PasswordValidation extends RegexValidation {
+    constructor(id, regex, message) {
+        super(id ?? 'PasswordValidation', regex ?? RegexPasswordNormal, message);
+    }
+}

package/dist/listgrid/validations/PhoneNumberValidation.d.ts

@@ -0,0 +1,12 @@
+import { RegexValidation } from '../validations/RegexValidation';
+import { ValidateResult } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class PhoneNumberValidation extends RegexValidation {
+    constructor(id?: string, regex?: RegExp, message?: string);
+    /**
+     * 전화번호 검증 시 하이픈을 제거한 후 검증합니다.
+     * 빈 값인 경우 검증을 통과시킵니다 (required 검증은 필드의 required 설정으로 처리).
+     */
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/PhoneNumberValidation.js

@@ -0,0 +1,24 @@
+import { RegexValidation } from '../validations/RegexValidation';
+import { RegexPhoneNumber } from '../misc';
+import { removePhoneNumberHyphens } from '../utils/PhoneUtil';
+import { isBlank } from '../utils/StringUtil';
+export class PhoneNumberValidation extends RegexValidation {
+    constructor(id, regex, message) {
+        super(id ?? 'PhoneNumberValidation', regex ?? RegexPhoneNumber, message ?? '전화번호 형식이 올바르지 않습니다.');
+    }
+    /**
+     * 전화번호 검증 시 하이픈을 제거한 후 검증합니다.
+     * 빈 값인 경우 검증을 통과시킵니다 (required 검증은 필드의 required 설정으로 처리).
+     */
+    async validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        // 빈 값이면 검증 통과 (required 검증은 필드의 required 설정으로 처리)
+        if (isBlank(currentValue)) {
+            return Promise.resolve(this.returnValidateResult(false, message));
+        }
+        // 하이픈 제거 후 검증
+        const digitsOnly = removePhoneNumberHyphens(currentValue);
+        const error = !this.regex.test(digitsOnly);
+        return Promise.resolve(this.returnValidateResult(error, message));
+    }
+}

package/dist/listgrid/validations/RegexFormularValidation.d.ts

@@ -0,0 +1,7 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class RegexFormulaValidation extends ValidationItem {
+    constructor(id: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/RegexFormularValidation.js

@@ -0,0 +1,28 @@
+import { ValidationItem } from '../validations/Validation';
+import { isBlank } from '../utils/StringUtil';
+// currentValue가 정규식 패턴인지 확인
+const regexPattern = /^\/.*\/[gimsuy]*$/;
+export class RegexFormulaValidation extends ValidationItem {
+    constructor(id) {
+        super(id);
+    }
+    validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        let error = true;
+        if (!isBlank(currentValue)) {
+            // 정규식의 메타 문자 포함 여부 확인
+            const containsMetaChars = /[\^\$\.\*\+\?\(\)\[\]\{\}\|\\]/.test(currentValue);
+            if (containsMetaChars) {
+                try {
+                    // 유효한 정규식인지 확인
+                    new RegExp(currentValue);
+                    error = false; // 정규식이 유효하다면 error를 false로 설정
+                }
+                catch (e) {
+                    error = true; // 정규식이 유효하지 않다면 error를 true로 유지
+                }
+            }
+        }
+        return Promise.resolve(this.returnValidateResult(error, '정규식 문자열을 입력해야 합니다.'));
+    }
+}

package/dist/listgrid/validations/RegexValidation.d.ts

@@ -0,0 +1,8 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class RegexValidation extends ValidationItem {
+    regex: RegExp;
+    constructor(id: string, regex: RegExp, message?: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/RegexValidation.js

@@ -0,0 +1,17 @@
+import { ValidationItem } from '../validations/Validation';
+import { isBlank } from '../utils/StringUtil';
+export class RegexValidation extends ValidationItem {
+    constructor(id, regex, message) {
+        super(id, message);
+        this.regex = regex;
+    }
+    validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        // required 에 대한 검증은 field 의 required 설정을 통해 해야 한다.
+        if (isBlank(currentValue)) {
+            return Promise.resolve(this.returnValidateResult(false, message));
+        }
+        const error = !this.regex.test(currentValue);
+        return Promise.resolve(this.returnValidateResult(error, message));
+    }
+}

package/dist/listgrid/validations/RequiredValidation.d.ts

@@ -0,0 +1,7 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class RequiredValidation extends ValidationItem {
+    constructor(id: string, message?: string);
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/RequiredValidation.js

@@ -0,0 +1,12 @@
+import { ValidationItem } from '../validations/Validation';
+import { isBlank } from '../utils/StringUtil';
+export class RequiredValidation extends ValidationItem {
+    constructor(id, message) {
+        super(id, message ?? '이 값은 반드시 입력해야 합니다.');
+    }
+    validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        const error = isBlank(currentValue);
+        return Promise.resolve(this.returnValidateResult(error, message));
+    }
+}

package/dist/listgrid/validations/StringValidation.d.ts

@@ -0,0 +1,17 @@
+import { ValidateResult, ValidationItem } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+import { MinMaxLimit } from '../form/Type';
+export declare class StringValidation extends ValidationItem {
+    length?: MinMaxLimit;
+    regex?: RegExp;
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+    constructor(args: {
+        length?: {
+            min?: number;
+            max?: number;
+        };
+        regex?: RegExp;
+        id: string;
+    }, message?: string);
+}

package/dist/listgrid/validations/StringValidation.js

@@ -0,0 +1,33 @@
+import { ValidationItem } from '../validations/Validation';
+export class StringValidation extends ValidationItem {
+    validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        if (this.length) {
+            if (this.length.min) {
+                if ((currentValue?.length ?? 0) < this.length.min) {
+                    return Promise.resolve(this.returnValidateResult(true, message ?? `Minimum length is ${this.length.min}`));
+                }
+            }
+            if (this.length.max) {
+                if ((currentValue?.length ?? 0) > this.length.max) {
+                    return Promise.resolve(this.returnValidateResult(true, message ?? `Maximum length is ${this.length.max}`));
+                }
+            }
+        }
+        if (this.regex) {
+            if (!this.regex.test(currentValue)) {
+                return Promise.resolve(this.returnValidateResult(true));
+            }
+        }
+        return Promise.resolve(this.returnValidateResult(false));
+    }
+    constructor(args, message) {
+        super(args.id ?? `StringValidation`, message);
+        if (args.length !== undefined) {
+            this.length = args.length;
+        }
+        if (args.regex !== undefined) {
+            this.regex = args.regex;
+        }
+    }
+}

package/dist/listgrid/validations/TelephoneNumberValidation.d.ts

@@ -0,0 +1,12 @@
+import { RegexValidation } from '../validations/RegexValidation';
+import { ValidateResult } from '../validations/Validation';
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export declare class TelephoneNumberValidation extends RegexValidation {
+    constructor(id?: string, regex?: RegExp, message?: string);
+    /**
+     * 전화번호 검증 시 하이픈을 제거한 후 검증합니다.
+     * 빈 값인 경우 검증을 통과시킵니다 (required 검증은 필드의 required 설정으로 처리).
+     */
+    validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+}

package/dist/listgrid/validations/TelephoneNumberValidation.js

@@ -0,0 +1,24 @@
+import { RegexValidation } from '../validations/RegexValidation';
+import { RegexTelephoneNumber } from '../misc';
+import { removePhoneNumberHyphens } from '../utils/PhoneUtil';
+import { isBlank } from '../utils/StringUtil';
+export class TelephoneNumberValidation extends RegexValidation {
+    constructor(id, regex, message) {
+        super(id ?? 'TelephoneNumberValidation', regex ?? RegexTelephoneNumber, message ?? '전화번호 형식이 올바르지 않습니다.');
+    }
+    /**
+     * 전화번호 검증 시 하이픈을 제거한 후 검증합니다.
+     * 빈 값인 경우 검증을 통과시킵니다 (required 검증은 필드의 required 설정으로 처리).
+     */
+    async validate(entityForm, value, message) {
+        const currentValue = this.getValueAsString(entityForm, value);
+        // 빈 값이면 검증 통과 (required 검증은 필드의 required 설정으로 처리)
+        if (isBlank(currentValue)) {
+            return Promise.resolve(this.returnValidateResult(false, message));
+        }
+        // 하이픈 제거 후 검증
+        const digitsOnly = removePhoneNumberHyphens(currentValue);
+        const error = !this.regex.test(digitsOnly);
+        return Promise.resolve(this.returnValidateResult(error, message));
+    }
+}

package/dist/listgrid/validations/Validation.d.ts

@@ -0,0 +1,63 @@
+import { EntityForm } from '../config/EntityForm';
+import { FieldValue } from '../config/Config';
+export interface Validation {
+    id: string;
+    message?: string;
+    /**
+     * 실제 검증 로직
+     * @param entityForm - 현재의 엔티티폼 상태
+     * @param value - 현재 필드의 필드값. FieldValue 타입인 경우 value.currentValue 가 현재 값
+     * @param message - 상위 폼에서 넘어 온 기본 오류 메시지
+     */
+    validate(entityForm: EntityForm, value: FieldValue | undefined, message?: string): Promise<ValidateResult>;
+    /**
+     * 에러 메시지 반환
+     */
+    getErrorMessage(): string;
+}
+export declare class ValidateResult {
+    error: boolean;
+    message: string;
+    constructor(error: boolean, message: string);
+    static fail(message: string): ValidateResult;
+    static success(): ValidateResult;
+    hasError(): boolean;
+    withMessage(message: string): this;
+}
+export declare abstract class ValidationItem implements Validation {
+    protected constructor(id: string, message?: string);
+    id: string;
+    message?: string;
+    /**
+     * 검증 로직
+     * @param entityForm
+     * @param value
+     * @param message
+     */
+    abstract validate(entityForm: EntityForm, value: FieldValue, message?: string): Promise<ValidateResult>;
+    getErrorMessage(): string;
+    /**
+     * 현재 필드값을 string 으로 반환하는 편의성 메소드
+     * @param entityForm
+     * @param value
+     */
+    getValueAsString(entityForm: EntityForm, value: FieldValue): string;
+    /**
+     * 현재 필드값을 number 로 반환하는 편의성 메소드
+     * @param entityForm
+     * @param value
+     */
+    getValueAsNumber(entityForm: EntityForm, value: FieldValue): number;
+    /**
+     * 현재 필드값을 boolean 로 반환하는 편의성 메소드.
+     * @param entityForm
+     * @param value
+     */
+    getValueAsBoolean(entityForm: EntityForm, value: FieldValue): boolean;
+    /**
+     * ValidateResult 를 반환하는 편의성 메소드.
+     * @param error
+     * @param message
+     */
+    returnValidateResult(error: boolean, message?: string): ValidateResult;
+}

package/dist/listgrid/validations/Validation.js

@@ -0,0 +1,72 @@
+const DEFAULT_ERROR_MESSAGE = 'form.save.error.invalid';
+export class ValidateResult {
+    constructor(error, message) {
+        this.error = error;
+        this.message = message;
+    }
+    static fail(message) {
+        return new ValidateResult(true, message);
+    }
+    static success() {
+        return new ValidateResult(false, '');
+    }
+    hasError() {
+        return this.error;
+    }
+    withMessage(message) {
+        this.message = message;
+        return this;
+    }
+}
+export class ValidationItem {
+    constructor(id, message) {
+        this.id = `${id}`;
+        if (message !== undefined) {
+            this.message = message;
+        }
+    }
+    getErrorMessage() {
+        return this.message ?? DEFAULT_ERROR_MESSAGE;
+    }
+    /**
+     * 현재 필드값을 string 으로 반환하는 편의성 메소드
+     * @param entityForm
+     * @param value
+     */
+    getValueAsString(entityForm, value) {
+        const currentValue = value?.current;
+        if (currentValue !== undefined) {
+            if (currentValue === null) {
+                return '';
+            }
+            return String(currentValue);
+        }
+        return entityForm.getRenderType() === 'update' ? value?.fetched : value?.default;
+    }
+    /**
+     * 현재 필드값을 number 로 반환하는 편의성 메소드
+     * @param entityForm
+     * @param value
+     */
+    getValueAsNumber(entityForm, value) {
+        return Number((value?.current ?? entityForm.getRenderType() === 'update') ? value?.fetched : value?.default);
+    }
+    /**
+     * 현재 필드값을 boolean 로 반환하는 편의성 메소드.
+     * @param entityForm
+     * @param value
+     */
+    getValueAsBoolean(entityForm, value) {
+        return Boolean((value?.current ?? entityForm.getRenderType() === 'update') ? value?.fetched : value?.default);
+    }
+    /**
+     * ValidateResult 를 반환하는 편의성 메소드.
+     * @param error
+     * @param message
+     */
+    returnValidateResult(error, message) {
+        return error
+            ? ValidateResult.fail(message ?? this.getErrorMessage())
+            : ValidateResult.success();
+    }
+}

package/dist/listgrid/view/ViewEntityFormWrapper.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { BreadcrumbItem } from '../ui';
+import { ViewEntityFormProps } from '../components/form/types/ViewEntityForm.types';
+interface ViewEntityFormWrapperProps {
+    props: ViewEntityFormProps;
+    breadcrumbs?: BreadcrumbItem[];
+    anonymous?: boolean;
+    /**
+     * 새창(팝업) 모드 여부
+     * - true일 때 Breadcrumb 숨김
+     * - ViewEntityFormProps에 popupMode 전달
+     */
+    popupMode?: boolean;
+}
+export declare const ViewEntityFormWrapper: React.FC<ViewEntityFormWrapperProps>;
+export {};