@rchemist/listgrid 0.2.6

package/dist/listgrid/utils/PhoneUtil.js

@@ -0,0 +1,38 @@
+/**
+ * 전화번호에서 하이픈을 제거합니다.
+ * @param phoneNumber 전화번호 문자열 (하이픈 포함 가능)
+ * @returns 하이픈이 제거된 숫자만 있는 문자열
+ * @example removePhoneNumberHyphens("010-1234-5678") => "01012345678"
+ * @example removePhoneNumberHyphens("01012345678") => "01012345678"
+ */
+export function removePhoneNumberHyphens(phoneNumber) {
+    if (!phoneNumber)
+        return '';
+    return phoneNumber.replace(/-/g, '');
+}
+/**
+ * 전화번호를 하이픈이 포함된 형식으로 포맷팅합니다.
+ * 10자리: 000-0000-0000 (예: 02-1234-5678)
+ * 11자리: 000-0000-0000 (예: 010-1234-5678)
+ * @param phoneNumber 전화번호 문자열 (숫자만)
+ * @returns 하이픈이 포함된 전화번호 문자열
+ * @example formatPhoneNumber("01012345678") => "010-1234-5678"
+ * @example formatPhoneNumber("0212345678") => "02-1234-5678"
+ * @example formatPhoneNumber("010-1234-5678") => "010-1234-5678" (이미 포맷팅된 경우)
+ */
+export function formatPhoneNumber(phoneNumber) {
+    if (!phoneNumber)
+        return '';
+    // 이미 하이픈이 포함되어 있으면 제거 후 다시 포맷팅
+    const digitsOnly = removePhoneNumberHyphens(phoneNumber);
+    if (digitsOnly.length === 10) {
+        // 10자리: 000-0000-0000 형식
+        return `${digitsOnly.substring(0, 3)}-${digitsOnly.substring(3, 6)}-${digitsOnly.substring(6)}`;
+    }
+    else if (digitsOnly.length === 11) {
+        // 11자리: 000-0000-0000 형식
+        return `${digitsOnly.substring(0, 3)}-${digitsOnly.substring(3, 7)}-${digitsOnly.substring(7)}`;
+    }
+    // 10자리 또는 11자리가 아닌 경우 원본 반환 (검증은 별도로 처리)
+    return digitsOnly;
+}

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

@@ -0,0 +1,6 @@
+import { callExternalHttpRequest as _call } from '../api';
+export declare const callExternalHttpRequest: typeof _call;
+export declare const RequestUtil: {
+    callExternalHttpRequest: typeof _call;
+};
+export default RequestUtil;

package/dist/listgrid/utils/RequestUtil.js

@@ -0,0 +1,6 @@
+// Thin compatibility shim pointing ExcelProvider at the host-configured ApiClient.
+// See src/listgrid/api/ApiClient.ts.
+import { callExternalHttpRequest as _call } from '../api';
+export const callExternalHttpRequest = _call;
+export const RequestUtil = { callExternalHttpRequest: _call };
+export default RequestUtil;

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

@@ -0,0 +1,32 @@
+export declare function isBlank(data: unknown): boolean;
+export declare function appendString(str: string | null | undefined, added: string[] | string | null | undefined, splitter?: string): string;
+export declare function subStringBeforeLast(value: string, splitCode: string): string;
+export declare function subStringBefore(value: string, splitCode: string): string;
+export declare function subStringAfterLast(value: string, splitCode: string): string;
+export declare function subStringAfter(value: string, splitCode: string): string;
+export declare function subStringBetween(value: string, startCode: string, endCode: string): string;
+export declare function subStringBetweenLast(value: string, startCode: string, endCode: string): string;
+export declare function defaultString(value: unknown, defaultValue?: string): string;
+export declare function appendPrefix(str: string, prefix: string, split?: string): string;
+export declare function appendSuffix(str: string, suffix: string, split?: string): string;
+export declare function removePrefix(str: string, prefix: string, split?: string): string;
+export declare function removeSuffix(str: string, suffix: string, split?: string): string;
+export declare function appendPrefixSuffix(str: string, prefix: string, suffix: string, split?: string): string;
+export declare function getHashCode(data: unknown): number;
+export declare function removeTrailingSeparator(input: string, separator: string): string;
+export declare function startsWith(value: string, prefix: string, ignoreCase?: boolean): boolean;
+export declare function endsWith(value?: string, postFix?: string, ignoreCase?: boolean): boolean;
+export declare function convertToCamelCase(input?: string): string;
+export declare function equalsIgnoreCase(value: string, other: string, trim?: boolean): boolean;
+export type WordPostfixType = '1' | '2';
+/**
+ * 단어 뒤에 '은', '는', '이', '가'를 선택적으로 붙여 준다.
+ * 한글에 대해서 유효하며, 한글이 아닌 단어는 제대로 되지 않지만 유사하게 처리된다.
+ * @param type
+ * @param word
+ */
+export declare function addKoreanWordPostfix(type: WordPostfixType, word?: string): string;
+export declare function generateSlug(input?: string): string;
+export declare function camelCaseToSnakeCase(camel: string, upperCase: boolean): string;
+export declare function splitWithSplitCode(value: string, split: string): string[];
+export declare function equalsIgnoreBlank(value: string | null | undefined, other: string | null | undefined): boolean;

package/dist/listgrid/utils/StringUtil.js

@@ -0,0 +1,316 @@
+import { stringify } from './jsonUtils';
+import { isTrue } from './BooleanUtil';
+export function isBlank(data) {
+    return data === undefined || data === null || data === '';
+}
+export function appendString(str, added, splitter) {
+    str = str === null || str === undefined ? '' : str;
+    const split = splitter === undefined ? ' ' : splitter;
+    if (isBlank(added)) {
+        return str;
+    }
+    if (Array.isArray(added)) {
+        for (const add of added) {
+            str += split + add;
+        }
+    }
+    else {
+        str += split + added;
+    }
+    return str;
+}
+export function subStringBeforeLast(value, splitCode) {
+    if (!value.includes(splitCode)) {
+        return value;
+    }
+    const split = value.split(splitCode);
+    let result = '';
+    for (let i = 0; i < split.length - 1; i++) {
+        result += split[i];
+        if (i < split.length - 2) {
+            result += splitCode;
+        }
+    }
+    return result;
+}
+export function subStringBefore(value, splitCode) {
+    if (!value.includes(splitCode)) {
+        return value;
+    }
+    const split = value.split(splitCode);
+    return defaultString(split[0]);
+}
+export function subStringAfterLast(value, splitCode) {
+    if (!value.includes(splitCode)) {
+        return value;
+    }
+    const split = value.split(splitCode);
+    return defaultString(split[split.length - 1]);
+}
+export function subStringAfter(value, splitCode) {
+    if (!value.includes(splitCode)) {
+        return value;
+    }
+    const split = value.split(splitCode);
+    let str = '';
+    for (let i = 1; i < split.length; i++) {
+        str += split[i];
+        if (i < split.length - 1) {
+            str += splitCode;
+        }
+    }
+    return str;
+}
+export function subStringBetween(value, startCode, endCode) {
+    return subStringBefore(subStringAfter(value, startCode), endCode);
+}
+export function subStringBetweenLast(value, startCode, endCode) {
+    return subStringBeforeLast(subStringAfterLast(value, startCode), endCode);
+}
+export function defaultString(value, defaultValue = '') {
+    if (isBlank(value)) {
+        return defaultValue;
+    }
+    else {
+        if (typeof value === 'string') {
+            return value;
+        }
+        else {
+            return String(value);
+        }
+    }
+}
+export function appendPrefix(str, prefix, split) {
+    if (!isBlank(split)) {
+        prefix = prefix + split;
+    }
+    if (str.startsWith(prefix)) {
+        return str;
+    }
+    if (!isBlank(split) && str.startsWith(split)) {
+        str = str.substring(split.length);
+    }
+    return prefix + str;
+}
+export function appendSuffix(str, suffix, split) {
+    if (!isBlank(split)) {
+        suffix = split + suffix;
+    }
+    if (str.endsWith(suffix)) {
+        return str;
+    }
+    if (!isBlank(split) && str.endsWith(split)) {
+        str = str.substring(0, str.length - split.length);
+    }
+    return str + suffix;
+}
+export function removePrefix(str, prefix, split) {
+    if (!isBlank(split)) {
+        prefix = prefix + split;
+    }
+    if (!str.startsWith(prefix)) {
+        return str;
+    }
+    return subStringAfter(str, prefix);
+}
+export function removeSuffix(str, suffix, split) {
+    if (!isBlank(split)) {
+        suffix = split + suffix;
+    }
+    if (!str.endsWith(suffix)) {
+        return str;
+    }
+    return subStringBeforeLast(str, suffix);
+}
+export function appendPrefixSuffix(str, prefix, suffix, split) {
+    return appendSuffix(appendPrefix(str, prefix, split), suffix, split);
+}
+export function getHashCode(data) {
+    if (data === null || data === undefined) {
+        return 0;
+    }
+    if (typeof data === 'string') {
+        let hash = 0;
+        if (data.length === 0) {
+            return hash;
+        }
+        for (let i = 0; i < data.length; i++) {
+            const char = data.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash;
+    }
+    else {
+        return getHashCode(stringify(data));
+    }
+}
+export function removeTrailingSeparator(input, separator) {
+    const parts = input.split(separator);
+    // 배열의 마지막 요소를 가져옵니다.
+    const lastPart = parts[parts.length - 1];
+    // 마지막 요소가 공백이 아니라면 '/'를 포함한 부분을 제거하고 반환합니다.
+    if (lastPart.trim() !== '') {
+        return input.slice(0, input.lastIndexOf(separator));
+    }
+    else {
+        // 마지막 요소가 공백이라면 입력값을 그대로 반환합니다.
+        return input;
+    }
+}
+export function startsWith(value, prefix, ignoreCase) {
+    if (value === undefined || prefix === undefined)
+        return false;
+    if (isTrue(ignoreCase)) {
+        return value.toLowerCase().startsWith(prefix.toLowerCase());
+    }
+    else {
+        return value.startsWith(prefix);
+    }
+}
+export function endsWith(value, postFix, ignoreCase) {
+    if (value === undefined || postFix === undefined)
+        return false;
+    if (isTrue(ignoreCase)) {
+        return value.toLowerCase().endsWith(postFix.toLowerCase()) ?? false;
+    }
+    else {
+        return value.endsWith(postFix) ?? false;
+    }
+}
+export function convertToCamelCase(input) {
+    // 입력이 없거나 공백인 경우
+    if (!input || input.trim().length === 0) {
+        return '';
+    }
+    // 공백 제거
+    input = input.trim();
+    // 문자열의 첫 글자를 소문자로 변환
+    let result = input.charAt(0).toLowerCase();
+    // 두 번째 글자부터 반복하여 처리
+    for (let i = 1; i < input.length; i++) {
+        // 현재 문자와 이전 문자가 둘 다 대문자이고, 이전 문자가 마지막 문자열이 아닐 때
+        if (input.charAt(i).toUpperCase() === input.charAt(i) &&
+            input.charAt(i - 1).toUpperCase() === input.charAt(i - 1) &&
+            i !== input.length - 1) {
+            // 현재 문자를 소문자로 변환하여 결과에 추가
+            result += input.charAt(i).toLowerCase();
+        }
+        else {
+            // 그 외의 경우는 그대로 결과에 추가
+            result += input.charAt(i);
+        }
+    }
+    return result;
+}
+export function equalsIgnoreCase(value, other, trim) {
+    if (isTrue(trim)) {
+        value = value.trim();
+        other = other.trim();
+    }
+    return value.toLowerCase() === other.toLowerCase();
+}
+// stripHtmlTags는 HtmlUtil에서 더 고급 버전으로 제공됩니다.
+// HtmlUtil의 stripHtmlTags를 사용하세요.
+function _stripHtmlTags(html) {
+    const regex = /<[^>]*>/g; // HTML 태그를 찾기 위한 정규식
+    return html.replace(regex, ''); // HTML 태그를 빈 문자열로 대체하여 제거
+}
+/**
+ * 단어 뒤에 '은', '는', '이', '가'를 선택적으로 붙여 준다.
+ * 한글에 대해서 유효하며, 한글이 아닌 단어는 제대로 되지 않지만 유사하게 처리된다.
+ * @param type
+ * @param word
+ */
+export function addKoreanWordPostfix(type, word) {
+    // word가 빈 문자열이거나 undefined면 빈 문자열을 리턴
+    if (!word)
+        return '';
+    // 한글의 유니코드 범위
+    const HANGUL_START = 0xac00;
+    const HANGUL_END = 0xd7a3;
+    // 단어의 마지막 글자를 가져옴
+    const lastChar = word[word.length - 1];
+    // 마지막 글자가 한글인 경우
+    if (lastChar.charCodeAt(0) >= HANGUL_START && lastChar.charCodeAt(0) <= HANGUL_END) {
+        const lastCharCode = lastChar.charCodeAt(0) - HANGUL_START;
+        const jongseong = lastCharCode % 28;
+        // 받침이 있는 경우
+        const hasJongseong = jongseong !== 0;
+        if (type === '1') {
+            return hasJongseong ? `${word}은` : `${word}는`;
+        }
+        else if (type === '2') {
+            return hasJongseong ? `${word}이` : `${word}가`;
+        }
+    }
+    // 영어 단어인 경우
+    const vowels = ['a', 'e', 'i', 'o', 'u'];
+    const isLastCharVowel = vowels.includes(lastChar.toLowerCase());
+    if (type === '1') {
+        return isLastCharVowel ? `${word}는` : `${word}은`;
+    }
+    else if (type === '2') {
+        return isLastCharVowel ? `${word}가` : `${word}이`;
+    }
+    return word; // 이 경우는 발생하지 않겠지만 안전성을 위해 추가
+}
+export function generateSlug(input) {
+    if (isBlank(input) || input === undefined) {
+        return '';
+    }
+    // 입력 문자열을 소문자로 변환
+    let modifiedString = input.toLowerCase();
+    // 한글, 영어, 숫자, 그리고 '-'만 남기기
+    modifiedString = modifiedString.replace(/[^a-z0-9가-힣\s-]/g, '');
+    // 연속된 공백을 하나의 공백으로 대체
+    modifiedString = modifiedString.replace(/\s+/g, ' ');
+    // 문자열에서 공백을 '-'로 대체
+    modifiedString = modifiedString.replace(/\s/g, '-');
+    // 변환된 문자열의 맨 앞에 '/'를 붙이되, 이미 '/'로 시작하면 추가하지 않음
+    if (!modifiedString.startsWith('/')) {
+        modifiedString = `/${modifiedString}`;
+    }
+    return modifiedString;
+}
+export function camelCaseToSnakeCase(camel, upperCase) {
+    // 먼저 "-" 문자를 "_"로 대체
+    camel = camel.replace(/-/g, '_');
+    let sb = [];
+    const length = camel.length;
+    for (let i = 0; i < length; ++i) {
+        const char = camel.charAt(i);
+        if (char === char.toUpperCase() && char !== '_' && sb.length > 0) {
+            sb.push('_');
+        }
+        sb.push(upperCase ? char.toUpperCase() : char.toLowerCase());
+    }
+    return sb.join('');
+}
+export function splitWithSplitCode(value, split) {
+    if (isBlank(value)) {
+        return [];
+    }
+    if (isBlank(split)) {
+        return [value];
+    }
+    const result = [];
+    for (const val of value.split(split)) {
+        if (!isBlank(val)) {
+            const trimmed = val.trim();
+            if (!isBlank(trimmed)) {
+                result.push(trimmed);
+            }
+        }
+    }
+    return result;
+}
+export function equalsIgnoreBlank(value, other) {
+    if (isBlank(value) && isBlank(other)) {
+        return true;
+    }
+    if (isBlank(value) || isBlank(other)) {
+        return false;
+    }
+    return equalsIgnoreCase(value, other, true);
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Per-slot override map accepted by field components.
+ * Keys are component-defined slot names (e.g. `root`, `input`, `label`, `error`).
+ * Values are any className string — Tailwind, scoped `rcm-*` classes, or CSS
+ * module identifiers; the merger treats them as opaque strings.
+ */
+export type ClassNamesMap<K extends string> = Partial<Record<K, string>>;
+/**
+ * Merge a component's built-in default class for a slot with a host override
+ * from the `classNames` prop. Built-ins come first so host overrides can win
+ * on the right when using tailwind-merge / plain cascade.
+ *
+ * Example:
+ *   <input className={mergeSlot('rcm-field-input', classNames?.input)} />
+ */
+export declare function mergeSlot(base: string, override?: string): string;
+/**
+ * Convenience when a component wants to expose a `classNames` slot map and
+ * resolve it up-front rather than calling `mergeSlot` per slot.
+ */
+export declare function resolveSlots<K extends string>(defaults: Record<K, string>, overrides?: ClassNamesMap<K>): Record<K, string>;

package/dist/listgrid/utils/classNames.js

@@ -0,0 +1,29 @@
+import { cn } from './cn';
+/**
+ * Merge a component's built-in default class for a slot with a host override
+ * from the `classNames` prop. Built-ins come first so host overrides can win
+ * on the right when using tailwind-merge / plain cascade.
+ *
+ * Example:
+ *   <input className={mergeSlot('rcm-field-input', classNames?.input)} />
+ */
+export function mergeSlot(base, override) {
+    if (!override)
+        return base;
+    return cn(base, override);
+}
+/**
+ * Convenience when a component wants to expose a `classNames` slot map and
+ * resolve it up-front rather than calling `mergeSlot` per slot.
+ */
+export function resolveSlots(defaults, overrides) {
+    if (!overrides)
+        return defaults;
+    const out = { ...defaults };
+    for (const key of Object.keys(overrides)) {
+        const value = overrides[key];
+        if (value)
+            out[key] = cn(defaults[key], value);
+    }
+    return out;
+}

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

@@ -0,0 +1,12 @@
+import { type ClassValue } from 'clsx';
+/**
+ * Tailwind CSS 클래스 병합 유틸리티
+ * - clsx로 조건부 클래스를 처리하고
+ * - tailwind-merge로 충돌하는 클래스를 스마트하게 병합
+ *
+ * @example
+ * cn("p-4", "p-2") // => "p-2" (마지막 값이 적용)
+ * cn("text-red-500", condition && "text-blue-500") // => 조건부 클래스
+ * cn(baseClass, customClass) // => 기본 클래스 + 커스텀 클래스 병합
+ */
+export declare const cn: (...inputs: ClassValue[]) => string;

package/dist/listgrid/utils/cn.js

@@ -0,0 +1,15 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+/**
+ * Tailwind CSS 클래스 병합 유틸리티
+ * - clsx로 조건부 클래스를 처리하고
+ * - tailwind-merge로 충돌하는 클래스를 스마트하게 병합
+ *
+ * @example
+ * cn("p-4", "p-2") // => "p-2" (마지막 값이 적용)
+ * cn("text-red-500", condition && "text-blue-500") // => 조건부 클래스
+ * cn(baseClass, customClass) // => 기본 클래스 + 커스텀 클래스 병합
+ */
+export const cn = (...inputs) => {
+    return twMerge(clsx(inputs));
+};

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

@@ -0,0 +1 @@
+export declare function hexHash(value: string): string;

package/dist/listgrid/utils/hash.js

@@ -0,0 +1,15 @@
+// Self-implemented hex hash to replace next/dist/shared/lib/hash#hexHash.
+//
+// The original Next.js internal hash is FNV-1a on a 32-bit accumulator,
+// formatted as unsigned hex. This implementation matches that behavior so
+// call sites (cache keys, React `key` props) keep stable output across
+// the framework-free migration.
+export function hexHash(value) {
+    let h = 0x811c9dc5; // FNV offset basis, 32-bit
+    for (let i = 0; i < value.length; i++) {
+        h ^= value.charCodeAt(i);
+        // FNV prime 16777619, force 32-bit via Math.imul
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16);
+}

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

@@ -0,0 +1,16 @@
+export interface TranslatorI18n {
+    language?: string;
+    changeLanguage?(lang: string): void;
+}
+export interface Translator {
+    t: (key: string, fallback?: string) => string;
+    i18n?: TranslatorI18n;
+    initLocale?: (themeLocale: string) => void;
+}
+/**
+ * Host apps pass a FACTORY (not a fixed translator) because language may
+ * change per call. The factory is invoked on every `getTranslation()` call.
+ */
+export type TranslatorFactory = () => Translator;
+export declare function configureTranslator(factory: TranslatorFactory): void;
+export declare function getTranslation(): Translator;

package/dist/listgrid/utils/i18n.js

@@ -0,0 +1,31 @@
+// i18n contract: library emits translation keys (e.g. "common.save",
+// "menu.academic.admission.notice"), host maps them to strings.
+//
+// Usage:
+//   import { configureTranslator } from '@rchemist/listgrid';
+//   configureTranslator(() => ({ t: myI18n.t, i18n: myI18n, initLocale: ... }));
+//
+// Library code then calls `getTranslation().t('key')` and gets the host's
+// translation. When no host is configured, `t(key)` returns the key itself
+// (identity translator) so UI is still renderable.
+let _factory;
+export function configureTranslator(factory) {
+    _factory = factory;
+}
+const DEFAULT_TRANSLATOR = {
+    t: (key, fallback) => fallback ?? key,
+    i18n: {},
+    initLocale: () => { },
+};
+export function getTranslation() {
+    if (_factory) {
+        try {
+            return _factory();
+        }
+        catch (e) {
+            console.warn('[@rchemist/listgrid] configured translator factory threw; falling back to identity.', e);
+            return DEFAULT_TRANSLATOR;
+        }
+    }
+    return DEFAULT_TRANSLATOR;
+}

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

@@ -0,0 +1,10 @@
+export * from './BooleanUtil';
+export * from './CompareUtil';
+export * from './PhoneUtil';
+export * from './StringUtil';
+export * from './jsonUtils';
+export { getTranslation } from './i18n';
+export { cn } from './cn';
+export * as simpleCrypt from './simpleCrypt';
+export { callExternalHttpRequest, getExternalApiData, getExternalApiDataWithError } from '../api';
+export declare function endsWith(value: string | undefined | null, suffix: string): boolean;

package/dist/listgrid/utils/index.js

@@ -0,0 +1,17 @@
+// Barrel re-exporting the inlined utilities used across listgrid.
+// Host-specific i18n is stubbed (see i18n.ts).
+export * from './BooleanUtil';
+export * from './CompareUtil';
+export * from './PhoneUtil';
+export * from './StringUtil';
+export * from './jsonUtils';
+export { getTranslation } from './i18n';
+export { cn } from './cn';
+export * as simpleCrypt from './simpleCrypt';
+// API call helpers delegate to the host-configured ApiClient (Stage 5).
+// See src/listgrid/api/ApiClient.ts.
+export { callExternalHttpRequest, getExternalApiData, getExternalApiDataWithError } from '../api';
+// String helpers absent from the inlined utils but used by original source.
+export function endsWith(value, suffix) {
+    return typeof value === 'string' && value.endsWith(suffix);
+}

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

@@ -0,0 +1,4 @@
+export declare function replacer(_key: string, value: unknown): unknown;
+export declare function reviver(_key: string, value: unknown): unknown;
+export declare function stringify(obj: unknown, beautify?: boolean): string;
+export { parse } from '../misc';

package/dist/listgrid/utils/jsonUtils.js

@@ -0,0 +1,77 @@
+// // type script 4.9 버그로 인해 TSON 을 사용할 수 없다.
+// import TSON from "typescript-json";
+export function replacer(_key, value) {
+    if (value instanceof Map) {
+        return {
+            dataType: 'Map',
+            value: Array.from(value.entries()), // or with spread: value: [...value]
+        };
+    }
+    else {
+        return value;
+    }
+}
+export function reviver(_key, value) {
+    if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (record.dataType === 'Map' && record.value) {
+            return new Map(record.value);
+        }
+    }
+    return value;
+}
+function mapReplacer(_key, value) {
+    if (value instanceof Map) {
+        return Object.fromEntries(value);
+    }
+    else if (value instanceof Set) {
+        return [...value];
+        // of course you can separate cases to turn Maps into objects
+    }
+    return value;
+}
+export function stringify(obj, beautify) {
+    // Circular reference를 처리하기 위한 WeakSet
+    const seen = new WeakSet();
+    const circularSafeReplacer = (key, value) => {
+        // 먼저 mapReplacer 적용
+        const mappedValue = mapReplacer(key, value);
+        // 객체가 아니거나 null인 경우 그대로 반환
+        if (typeof mappedValue !== 'object' || mappedValue === null) {
+            return mappedValue;
+        }
+        // Circular reference 체크
+        if (seen.has(mappedValue)) {
+            return '[Circular Reference]';
+        }
+        seen.add(mappedValue);
+        return mappedValue;
+    };
+    try {
+        if (beautify) {
+            return JSON.stringify(obj, circularSafeReplacer, 2);
+        }
+        return JSON.stringify(obj, circularSafeReplacer);
+    }
+    catch (error) {
+        console.error('stringify error:', error);
+        return '{}';
+    }
+}
+const simpleStringify = (object) => {
+    for (const eachIdx in object) {
+        if (object[eachIdx] instanceof Map) {
+            object[eachIdx] = Array.from(object[eachIdx]);
+            simpleStringify(object);
+        }
+        else if (typeof object[eachIdx] == 'object' && object[eachIdx] !== null) {
+            simpleStringify(object[eachIdx]);
+        }
+    }
+    return JSON.stringify(object);
+};
+// Re-export from `misc` — `parse<T = unknown>` is the canonical generic
+// implementation. Prior duplicate definition was merged into `misc`.
+// This re-export preserves existing `import { parse } from '../utils/jsonUtils'`
+// paths for backward-compat.
+export { parse } from '../misc';

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

@@ -0,0 +1,10 @@
+import React, { ComponentType } from 'react';
+export interface LazyImportOptions {
+    loading?: () => React.ReactNode;
+    /** Ignored. Kept for next/dynamic API parity. */
+    ssr?: boolean;
+}
+export declare function lazyImport<P = any>(loader: () => Promise<{
+    default: ComponentType<any>;
+}>, options?: LazyImportOptions): ComponentType<P>;
+export { lazyImport as dynamic };