@rchemist/listgrid 0.2.6

package/dist/listgrid/config/EntityFormButton.d.ts

@@ -0,0 +1,56 @@
+import { EntityForm } from '../config/EntityForm';
+import { ReactNode } from 'react';
+import { LabelType } from '../config/Config';
+import { ModalOptions } from '../store';
+import type { RouterApi } from '../router/types';
+export interface EntityFormButtonStepInfo {
+    useCreateStep: boolean;
+    currentStep: number;
+    maxStep: number;
+    createStepFields: string[];
+}
+export interface EntityFormButtonProps {
+    entityForm: EntityForm;
+    router: RouterApi;
+    pathname: string | null;
+    setErrors: (errors: string[]) => void;
+    setNotifications: (notifications: string[]) => void;
+    step?: EntityFormButtonStepInfo;
+    showModal?: (options: ModalOptions) => string;
+    closeModal?: (id: string) => Promise<void>;
+    closeTopModal?: () => Promise<void>;
+    getModalData?: (id: string) => unknown;
+    updateModalData?: (id: string, data: Partial<ModalOptions>) => void;
+}
+/**
+ * ReactNode 버튼을 위한 래퍼 타입
+ * ID를 가진 ReactNode로 중복 방지 가능
+ */
+export interface EntityFormReactNodeButton {
+    id: string;
+    button: ReactNode;
+}
+/**
+ * EntityForm에서 사용할 수 있는 버튼 타입
+ */
+export type EntityFormButtonType = EntityFormButton | EntityFormReactNodeButton;
+export declare class EntityFormButton {
+    readonly id: string;
+    icon?: ReactNode | undefined;
+    label?: LabelType | undefined;
+    className?: string | undefined;
+    onClick?: ((props: EntityFormButtonProps) => Promise<EntityForm>) | undefined;
+    disabled?: ((props: EntityFormButtonProps) => Promise<boolean>) | undefined;
+    hidden?: ((props: EntityFormButtonProps) => Promise<boolean>) | undefined;
+    tooltip?: ((props: EntityFormButtonProps) => Promise<ReactNode>) | undefined;
+    constructor(id: string);
+    getId(): string;
+    isOverwrite(id: string): boolean;
+    withIcon(icon?: ReactNode): this;
+    withLabel(label?: ReactNode): this;
+    withClassName(className?: string): this;
+    withOnClick(onClick?: (props: EntityFormButtonProps) => Promise<EntityForm>): this;
+    withDisabled(disabled?: (props: EntityFormButtonProps) => Promise<boolean>): this;
+    withHidden(hidden?: (props: EntityFormButtonProps) => Promise<boolean>): this;
+    withTooltip(tooltip?: (props: EntityFormButtonProps) => Promise<ReactNode>): this;
+}

package/dist/listgrid/config/EntityFormButton.js

@@ -0,0 +1,42 @@
+import { isEqualsIgnoreCase } from '../misc';
+export class EntityFormButton {
+    constructor(id) {
+        this.id = id;
+    }
+    // 버튼 ID를 반환
+    getId() {
+        return this.id;
+    }
+    // id 가 save 이거나 delete 인 경우에는 기존의 entityForm 버튼을 대체한다.
+    isOverwrite(id) {
+        return isEqualsIgnoreCase(this.id, id);
+    }
+    withIcon(icon) {
+        this.icon = icon;
+        return this;
+    }
+    withLabel(label) {
+        this.label = label;
+        return this;
+    }
+    withClassName(className) {
+        this.className = className;
+        return this;
+    }
+    withOnClick(onClick) {
+        this.onClick = onClick;
+        return this;
+    }
+    withDisabled(disabled) {
+        this.disabled = disabled;
+        return this;
+    }
+    withHidden(hidden) {
+        this.hidden = hidden;
+        return this;
+    }
+    withTooltip(tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+}

package/dist/listgrid/config/EntityFormMethod.d.ts

@@ -0,0 +1,32 @@
+import { IEntityError } from '../api';
+import { FieldError } from './EntityFormTypes';
+import { EntityForm } from './EntityForm';
+export declare function entityErrorToString(entityError: IEntityError): string;
+export declare function mergeFieldErrors(origin: FieldError[], errors: FieldError[]): FieldError[];
+interface ApiErrorResponse {
+    error?: string | {
+        message?: string;
+        fieldError?: unknown;
+    } | unknown;
+    entityError?: {
+        error?: string | {
+            message?: string;
+            fieldError?: unknown;
+        };
+    };
+}
+/**
+ * API 응답 에러를 처리하고 필드 에러와 글로벌 에러를 추출합니다.
+ * EntityForm의 save 메소드에서 사용하는 에러 처리 로직을 재사용 가능하도록 추출한 함수입니다.
+ *
+ * @param response - API 응답 객체 (error, entityError 포함 가능)
+ * @param form - 필드 라벨을 가져오기 위한 EntityForm (optional)
+ * @returns 처리된 에러 정보
+ */
+export declare function processApiError(response: ApiErrorResponse, form?: EntityForm): {
+    fieldErrors: FieldError[];
+    globalError?: string | undefined;
+    hasError: boolean;
+};
+export declare function delay(ms: number): Promise<void>;
+export {};

package/dist/listgrid/config/EntityFormMethod.js

@@ -0,0 +1,152 @@
+import { isTrue } from '../utils/BooleanUtil';
+import { parse } from '../utils/jsonUtils';
+export function entityErrorToString(entityError) {
+    if (entityError.error) {
+        if (isTrue(entityError.error.error)) {
+            if (entityError.error.fieldError) {
+                const entries = entityError.error.fieldError instanceof Map
+                    ? Array.from(entityError.error.fieldError.entries())
+                    : Object.entries(entityError.error.fieldError);
+                return entries
+                    .map(([key, value]) => `${key}: ${value.join(', ')}`)
+                    .join(', ');
+            }
+            if (entityError.error.message) {
+                return entityError.error.message;
+            }
+        }
+    }
+    return 'failed to parse error';
+}
+export function mergeFieldErrors(origin, errors) {
+    const mergedMap = new Map();
+    // 먼저 origin 배열의 필드 오류들을 Map에 추가
+    for (const error of origin) {
+        mergedMap.set(error.name, { ...error });
+    }
+    // errors 배열을 순회하며 병합
+    for (const error of errors) {
+        if (mergedMap.has(error.name)) {
+            // 기존 오류가 있을 경우 errors 배열을 병합
+            const existingError = mergedMap.get(error.name);
+            mergedMap.set(error.name, {
+                ...existingError,
+                errors: Array.from(new Set([...existingError.errors, ...error.errors])), // 중복 제거
+                tabId: existingError.tabId || error.tabId, // tabId가 없으면 새로 할당
+            });
+        }
+        else {
+            // 기존 오류가 없으면 새로 추가
+            mergedMap.set(error.name, { ...error });
+        }
+    }
+    // Map을 배열로 변환하여 반환
+    return Array.from(mergedMap.values());
+}
+/**
+ * API 응답 에러를 처리하고 필드 에러와 글로벌 에러를 추출합니다.
+ * EntityForm의 save 메소드에서 사용하는 에러 처리 로직을 재사용 가능하도록 추출한 함수입니다.
+ *
+ * @param response - API 응답 객체 (error, entityError 포함 가능)
+ * @param form - 필드 라벨을 가져오기 위한 EntityForm (optional)
+ * @returns 처리된 에러 정보
+ */
+export function processApiError(response, form) {
+    const fieldErrors = [];
+    let globalError;
+    let jsonError = false;
+    if (response.error) {
+        try {
+            // intentional: errorObject has heterogeneous shape depending on backend error variant
+            let errorObject;
+            // entityError가 있으면 구조화된 정보 사용
+            if (response.entityError) {
+                // entityError.error가 객체인지 문자열인지 확인
+                if (typeof response.entityError.error === 'object' && response.entityError.error !== null) {
+                    errorObject = response.entityError.error;
+                }
+                else if (typeof response.entityError.error === 'string') {
+                    // 문자열인 경우 message로 설정
+                    errorObject = { message: response.entityError.error };
+                }
+                else {
+                    // entityError 전체를 사용
+                    errorObject = response.entityError;
+                }
+                jsonError = true;
+            }
+            else if (typeof response.error === 'string') {
+                // response.error가 문자열인 경우 JSON 파싱 시도
+                try {
+                    const parsed = parse(response.error);
+                    errorObject = parsed.error ?? parsed;
+                    jsonError = true;
+                }
+                catch (parseError) {
+                    // JSON이 아닌 단순 문자열인 경우
+                    globalError = response.error;
+                    jsonError = false;
+                }
+            }
+            else {
+                // response.error가 객체인 경우
+                errorObject = response.error;
+            }
+            if (errorObject) {
+                // 필드 에러 처리
+                if (errorObject.fieldError) {
+                    // Map인 경우와 일반 객체인 경우 모두 처리
+                    if (errorObject.fieldError instanceof Map) {
+                        errorObject.fieldError.forEach((fieldError, fieldName) => {
+                            const label = form?.getLabel(fieldName) ?? '저장 오류';
+                            fieldErrors.push({ name: fieldName, label: label, errors: fieldError });
+                        });
+                    }
+                    else if (typeof errorObject.fieldError === 'object') {
+                        Object.entries(errorObject.fieldError).forEach(([fieldName, fieldError]) => {
+                            const label = form?.getLabel(fieldName) ?? '저장 오류';
+                            fieldErrors.push({ name: fieldName, label: label, errors: fieldError });
+                        });
+                    }
+                }
+                // 글로벌 에러 메시지 처리
+                if (!globalError && errorObject.message) {
+                    globalError = errorObject.message;
+                    jsonError = true;
+                }
+            }
+        }
+        catch (e) {
+            // 에러가 json 타입이 아니라면 실제 시스템 에러다.
+            console.error('Error processing exception:', response.error, e);
+        }
+    }
+    // 에러 메시지 결정
+    let errorMessage;
+    let hasError;
+    if (fieldErrors.length > 0) {
+        // 필드 에러가 있으면 일반 에러 메시지는 표시하지 않지만, 에러 상태임은 표시
+        errorMessage = undefined;
+        hasError = true;
+    }
+    else {
+        // 필드 에러가 없을 때만 일반 에러 메시지 표시
+        errorMessage =
+            (!jsonError
+                ? typeof response.error === 'string'
+                    ? response.error
+                    : undefined
+                : globalError
+                    ? globalError
+                    : undefined) ?? '저장 중 오류가 발생했습니다.';
+        hasError = true;
+    }
+    return {
+        fieldErrors,
+        globalError: errorMessage,
+        hasError,
+    };
+}
+export function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/listgrid/config/EntityFormTypes.d.ts

@@ -0,0 +1,62 @@
+import { ModalOptions } from '../store';
+import { ReactNode } from 'react';
+import { CommonFieldProps } from '../components/fields/Preset';
+import { IDataTransferConfig } from '../transfer/Type';
+import { FieldGroupInfo, HelpTextType, HiddenType, ReadOnlyType, RequiredType, TabInfo } from './Config';
+import { EntityForm } from './EntityForm';
+import { EntityItem } from './EntityItem';
+import { ColorType } from '../common/type';
+export type CopyEntityFormExplicitFieldType = string | CopyEntityFormOverrideFieldProps;
+export interface CopyEntityFormToInnerFieldsProps {
+    prefix: string;
+    entityForm: EntityForm;
+    tab?: TabInfo;
+    fieldGroup?: FieldGroupInfo;
+    excludeFields?: string[];
+    explicitFields?: CopyEntityFormExplicitFieldType[];
+}
+export interface CopyEntityFormOverrideFieldProps extends CommonFieldProps {
+    tab?: TabInfo;
+    fieldGroup?: FieldGroupInfo;
+    helpText?: HelpTextType;
+    hidden?: HiddenType;
+    readonly?: ReadOnlyType;
+    required?: RequiredType;
+}
+export interface AddFieldItemProps extends AbstractAddFieldProps {
+    items: EntityItem[];
+    overwrite?: boolean;
+}
+export interface AbstractAddFieldProps {
+    tab?: TabInfo;
+    fieldGroup?: FieldGroupInfo;
+}
+export interface SubmitFormData {
+    data: any;
+    modifiedFields: string[];
+    errors: FieldError[];
+    error: boolean;
+}
+export interface FieldError {
+    name: string;
+    label: string | ReactNode | false;
+    errors: string[];
+    tabId?: string | undefined;
+    errorId?: string | undefined;
+}
+export interface AlertMessageLink {
+    type?: 'tab' | 'field' | 'external' | 'modal';
+    value: string | ModalOptions;
+    target?: '_self' | '_blank' | '_parent' | '_top';
+}
+export interface AlertMessage {
+    key: string;
+    message: string | ReactNode;
+    description?: ReactNode;
+    color: ColorType;
+    persistent?: boolean;
+    link?: AlertMessageLink;
+}
+export interface DataTransferConfigProps extends IDataTransferConfig {
+    fieldNames?: string[] | undefined;
+}

package/dist/listgrid/config/EntityFormTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/listgrid/config/EntityItem.d.ts

@@ -0,0 +1,86 @@
+import { HelpTextType, HiddenType, LabelType, ReadOnlyType, TooltipType, ViewPreset } from '../config/Config';
+import { ReactNode } from 'react';
+import { FieldInfoParameters } from '../config/EntityField';
+export interface EntityItem {
+    order: number;
+    name: string;
+    label?: LabelType | undefined;
+    helpText?: HelpTextType | undefined;
+    hidden?: HiddenType | undefined;
+    readonly?: ReadOnlyType | undefined;
+    hideLabel?: boolean | undefined;
+    form?: {
+        tabId: string;
+        fieldGroupId: string;
+    } | undefined;
+    clone(includeValue?: boolean): any;
+    getTabId(): string;
+    getFieldGroupId(): string;
+    /**
+     * 필드가 표시될 tab의 id 를 지정합니다.
+     * 보통 이 메소드는 EntityForm#addFields 에서 처리되므로 별도로 사용할 필요가 없습니다.
+     * @param tabId
+     */
+    withTabId(tabId: string): this;
+    /**
+     * 필드가 표시될 fieldGroup 의 id 를 지정합니다.
+     * 보통 이 메소드는 EntityForm#addFields 에서 처리되므로 별도로 사용할 필요가 없습니다.
+     * @param fieldGroupId
+     */
+    withFieldGroupId(fieldGroupId: string): this;
+    /**
+     * Entity 의 상태(신규/수정)에 따라 readonly, hidden 을 ViewPreset 으로 지정해 사용할 수 있습니다.
+     * @param type
+     */
+    withViewPreset(type: ViewPreset): this;
+    /**
+     * 필드 입력폼 하단에 출력될 helpText 를 지정할 수 있습니다.
+     * @param helpText
+     */
+    withHelpText(helpText?: HelpTextType): this;
+    /**
+     * 필드 전체에 툴팁을 씌울 수 있다.
+     * @param tooltip
+     */
+    withTooltip(tooltip?: TooltipType): this;
+    /**
+     * 필드의 visible 옵션을 설정할 수 있습니다.
+     * @param hidden
+     */
+    withHidden(hidden?: HiddenType): this;
+    /**
+     * 필드 입력폼의 라벨에 표시될 내용을 설정할 수 있습니다.
+     * @param label
+     */
+    withLabel(label?: LabelType): this;
+    /**
+     * 필드가 readonly 인지 여부를 설정할 수 있습니다.
+     * @param readOnly
+     */
+    withReadOnly(readOnly?: ReadOnlyType): this;
+    /**
+     * 이 필드의 hideLabel 을 지정한다.
+     * @param hideLabel
+     */
+    withHideLabel(hideLabel?: boolean): this;
+    /**
+     * 필드의 표시 순서를 설정합니다.
+     * @param order
+     */
+    withOrder(order: number): this;
+    getOrder(): number;
+    getName(): string;
+    getLabel(): LabelType;
+    getHelpText(props: FieldInfoParameters): Promise<ReactNode>;
+    isHidden(props: FieldInfoParameters): Promise<boolean>;
+    isReadonly(props: FieldInfoParameters): Promise<boolean>;
+    /**
+     * 필드가 표시될 tabId 와 fieldGroupId 를 설정합니다.
+     * withTabId, withFieldGroupId 를 한번에 지정하는 것과 같습니다.
+     * @param form
+     */
+    withForm(form: {
+        tabId: string;
+        fieldGroupId: string;
+    }): this;
+}

package/dist/listgrid/config/EntityItem.js

@@ -0,0 +1 @@
+export {};

package/dist/listgrid/config/EntityTab.d.ts

@@ -0,0 +1,26 @@
+import { FieldGroupInfo, TabInfo } from '../config/Config';
+import { EntityFieldGroup } from '../config/EntityFieldGroup';
+import { EntityItem } from '../config/EntityItem';
+export declare class EntityTab {
+    id: string;
+    label: string;
+    order: number;
+    hidden?: boolean | undefined;
+    description?: string | React.ReactNode;
+    fieldGroups: EntityFieldGroup[];
+    requiredPermissions?: string[] | undefined;
+    constructor(config?: TabInfo);
+    /**
+     * 이 탭을 보기 위해 필요한 권한을 설정합니다.
+     * 사용자가 지정된 권한 중 하나라도 가지고 있으면 탭이 표시됩니다.
+     */
+    withRequiredPermissions(...permissions: string[]): this;
+    /**
+     * 사용자가 이 탭을 볼 수 있는 권한이 있는지 확인합니다.
+     * requiredPermissions가 없거나 비어있으면 true를 반환합니다.
+     * 사용자가 requiredPermissions 중 하나라도 가지고 있으면 true를 반환합니다.
+     */
+    isPermitted(userPermissions?: string[]): boolean;
+    clone(): EntityTab;
+    addField(fieldGroup: FieldGroupInfo, field: EntityItem): void;
+}

package/dist/listgrid/config/EntityTab.js

@@ -0,0 +1,68 @@
+import { isTrue } from '../utils/BooleanUtil';
+import { EntityFieldGroup } from '../config/EntityFieldGroup';
+export class EntityTab {
+    constructor(config) {
+        this.fieldGroups = [];
+        this.id = config?.id ?? 'default';
+        this.order = config?.order ?? 100;
+        this.label = config?.label ?? '기본 정보';
+        this.hidden = isTrue(config?.hidden);
+        this.description = config?.description;
+        this.requiredPermissions = config?.requiredPermissions;
+    }
+    /**
+     * 이 탭을 보기 위해 필요한 권한을 설정합니다.
+     * 사용자가 지정된 권한 중 하나라도 가지고 있으면 탭이 표시됩니다.
+     */
+    withRequiredPermissions(...permissions) {
+        if (!this.requiredPermissions) {
+            this.requiredPermissions = [];
+        }
+        const uniquePermissions = new Set([...this.requiredPermissions, ...permissions]);
+        this.requiredPermissions = Array.from(uniquePermissions);
+        return this;
+    }
+    /**
+     * 사용자가 이 탭을 볼 수 있는 권한이 있는지 확인합니다.
+     * requiredPermissions가 없거나 비어있으면 true를 반환합니다.
+     * 사용자가 requiredPermissions 중 하나라도 가지고 있으면 true를 반환합니다.
+     */
+    isPermitted(userPermissions) {
+        if (!this.requiredPermissions || this.requiredPermissions.length === 0) {
+            return true;
+        }
+        if (!userPermissions || userPermissions.length === 0) {
+            return false;
+        }
+        return this.requiredPermissions.some((permission) => userPermissions.includes(permission));
+    }
+    clone() {
+        const cloned = new EntityTab();
+        cloned.id = this.id;
+        cloned.label = this.label;
+        cloned.order = this.order;
+        cloned.hidden = this.hidden;
+        cloned.description = this.description;
+        cloned.requiredPermissions = this.requiredPermissions
+            ? [...this.requiredPermissions]
+            : undefined;
+        const fieldGroups = [];
+        this.fieldGroups.forEach((fieldGroup) => {
+            fieldGroups.push(fieldGroup.clone());
+        });
+        cloned.fieldGroups = fieldGroups;
+        return cloned;
+    }
+    addField(fieldGroup, field) {
+        let entityFieldGroup = this.fieldGroups.find((group) => group.id === fieldGroup.id);
+        if (!entityFieldGroup) {
+            entityFieldGroup = new EntityFieldGroup(fieldGroup);
+            this.fieldGroups.push(entityFieldGroup);
+            this.fieldGroups.sort((a, b) => a.order - b.order);
+        }
+        // 이미 존재하는지 확인 후 없으면 추가
+        if (!entityFieldGroup.fields.some((fld) => fld.name === field.name)) {
+            entityFieldGroup.fields.push({ name: field.getName(), order: field.getOrder() });
+        }
+    }
+}