@rchemist/listgrid 0.2.6

package/dist/listgrid/config/form/EntityFormData.js

@@ -0,0 +1,184 @@
+import { isBlank, isEmpty, isTrue } from '../../utils';
+import { EntityFormValidation } from './EntityFormValidation';
+import { DEFAULT_FIELD_GROUP_INFO, DEFAULT_TAB_INFO, } from '../../config/Config';
+import { EntityFieldGroup } from '../../config/EntityFieldGroup';
+import { EntityTab } from '../../config/EntityTab';
+export class EntityFormData extends EntityFormValidation {
+    constructor(name, url) {
+        super(name, url);
+    }
+    resetValue(fieldName, loadOnChanges = true) {
+        const field = this.getField(fieldName);
+        if (field) {
+            field.resetValue(this.getRenderType());
+            if (loadOnChanges) {
+                this.executeOnChanges(fieldName);
+            }
+        }
+        return this;
+    }
+    setValue(fieldName, value) {
+        const field = this.getField(fieldName);
+        if (field) {
+            this.fields.set(field.getName(), field.withValue(value));
+        }
+        return this;
+    }
+    setValues(cloned) {
+        // fields 의 value 를 복사해 붙인다.
+        this.fields.forEach((field, key) => {
+            const clonedField = cloned.getField(key);
+            if (clonedField) {
+                field.value = clonedField.value;
+            }
+        });
+        return this;
+    }
+    changeValue(fieldName, value) {
+        const field = this.getField(fieldName);
+        if (field) {
+            this.fields.set(field.getName(), field.withValue(value));
+            this.executeOnChanges(fieldName);
+        }
+        return this;
+    }
+    clearOnChanges() {
+        this.onChanges = [];
+        return this;
+    }
+    clearOnFetchData() {
+        this.onFetchData = [];
+        return this;
+    }
+    clearOnInitialize() {
+        this.onInitialize = [];
+        return this;
+    }
+    clearOnPostFetchListData() {
+        this.onFetchListData = [];
+        return this;
+    }
+    isDirty() {
+        // 모든 필드 요소를 순회하며 dirty 여부를 확인한다.
+        for (const field of this.fields.values()) {
+            if (!isTrue(field.hidden) && field.isDirty()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isDirtyField(name) {
+        const field = this.getField(name);
+        return field ? field.isDirty() : false;
+    }
+    copyEntityFormToInnerFields({ prefix, entityForm, ...props }) {
+        const fields = entityForm.getFields();
+        if (isEmpty(fields)) {
+            return;
+        }
+        const excludeFields = props.excludeFields ?? [];
+        const explicitFields = props.explicitFields ?? [];
+        let tab = props.tab ?? DEFAULT_TAB_INFO;
+        if (props.tab) {
+            if (!this.hasTab(props.tab.id)) {
+                tab = props.tab;
+                this.tabs.set(props.tab.id, new EntityTab(tab));
+            }
+        }
+        let fieldGroup = props.fieldGroup ?? DEFAULT_FIELD_GROUP_INFO;
+        let entityFieldGroup;
+        if (this.tabs.get(tab.id)?.fieldGroups.find((group) => group.id === fieldGroup.id)) {
+            entityFieldGroup = this.tabs
+                .get(tab.id)
+                .fieldGroups.find((group) => group.id === fieldGroup.id);
+        }
+        else {
+            entityFieldGroup = new EntityFieldGroup(fieldGroup);
+            this.tabs.get(tab.id)?.fieldGroups.push(entityFieldGroup);
+        }
+        for (const field of fields) {
+            if (excludeFields.includes(field.getName())) {
+                continue;
+            }
+            let includeField = isEmpty(explicitFields);
+            let explicitFieldInfo = undefined;
+            if (!includeField) {
+                for (const explicitField of explicitFields) {
+                    if (typeof explicitField === 'string') {
+                        if (explicitField === field.getName()) {
+                            includeField = true;
+                            break;
+                        }
+                    }
+                    else {
+                        if (explicitField.name === field.getName()) {
+                            includeField = true;
+                            explicitFieldInfo = explicitField;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (includeField) {
+                let newName = `${explicitFieldInfo?.name ?? field.getName()}`;
+                if (!isBlank(prefix)) {
+                    newName = `${prefix}.${newName}`;
+                }
+                const newField = field.clone(true);
+                if (explicitFieldInfo?.order) {
+                    newField.withOrder(explicitFieldInfo.order);
+                }
+                if (explicitFieldInfo?.label) {
+                    newField.withLabel(explicitFieldInfo.label);
+                }
+                if (explicitFieldInfo?.helpText) {
+                    newField.withHelpText(explicitFieldInfo.helpText);
+                }
+                if (explicitFieldInfo?.hidden) {
+                    newField.withHidden(explicitFieldInfo.hidden);
+                }
+                if (explicitFieldInfo?.readonly) {
+                    newField.withReadOnly(explicitFieldInfo.readonly);
+                }
+                if (explicitFieldInfo?.required) {
+                    newField.withRequired(explicitFieldInfo.required);
+                }
+                newField.name = newName;
+                newField.withTabId(explicitFieldInfo?.tab?.id ?? tab.id);
+                newField.withFieldGroupId(explicitFieldInfo?.fieldGroup?.id ?? fieldGroup.id);
+                // 탭 정보가 필드 단위로 변경된 경우
+                if (explicitFieldInfo?.tab || explicitFieldInfo?.fieldGroup) {
+                    let newTab = tab;
+                    if (tab.id !== newField.getTabId()) {
+                        if (this.tabs.has(newField.getTabId())) {
+                            newTab = this.tabs.get(newField.getTabId());
+                        }
+                        // 기존 탭이 없는 경우에는 추가해야 한다.
+                        if (!newTab) {
+                            newTab = explicitFieldInfo.tab;
+                            this.tabs.set(newTab.id, new EntityTab(newTab));
+                        }
+                    }
+                    // 필드 그룹 정보가 필드 단위로 변경된 경우
+                    let newFieldGroup;
+                    if (this.tabs
+                        .get(newTab.id)
+                        ?.fieldGroups.find((group) => group.id === newField.getFieldGroupId())) {
+                        newFieldGroup = this.tabs
+                            .get(newTab.id)
+                            .fieldGroups.find((group) => group.id === newField.getFieldGroupId());
+                    }
+                    else {
+                        newFieldGroup = new EntityFieldGroup(explicitFieldInfo?.fieldGroup ?? fieldGroup);
+                        this.tabs.get(newTab.id)?.fieldGroups.push(newFieldGroup);
+                    }
+                    newFieldGroup.fields.push(newField);
+                }
+                else {
+                    entityFieldGroup.fields.push(newField);
+                }
+                this.fields.set(newName, newField);
+            }
+        }
+    }
+}

package/dist/listgrid/config/form/EntityFormExtensions.d.ts

@@ -0,0 +1,37 @@
+import { SearchForm } from '../../form/SearchForm';
+import { PageResult } from '../../form/Type';
+import { ExtensionPoint, ClientExtensionFunction, ExtensionOptions, ClientExtensionConfig, ClientExtensionContext } from '../../extensions/EntityFormExtension.types';
+import { EntityFormActions } from '../../config/form/EntityFormActions';
+export declare abstract class EntityFormExtensions<T extends object = any> extends EntityFormActions<T> {
+    constructor(name: string, url: string);
+    /**
+     * Client Extension 추가 메소드 (내부용)
+     */
+    private withClientExtension;
+    withClientPreFetchList(handler: ClientExtensionFunction<SearchForm>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPostFetchList(handler: ClientExtensionFunction<PageResult>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPreCreate(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPostCreate(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPreRead(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPostRead(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPreUpdate(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPostUpdate(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPreDelete(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    withClientPostDelete(handler: ClientExtensionFunction<any>, options?: Omit<ExtensionOptions, 'executionContext'>): this;
+    /**
+     * Client Extension 실행
+     */
+    executeClientExtensions<T>(point: ExtensionPoint, data: T, context: ClientExtensionContext): Promise<T>;
+    /**
+     * Client Extensions 존재 여부 확인
+     */
+    hasClientExtensions(...points: ExtensionPoint[]): boolean;
+    /**
+     * 특정 Extension Point의 Client Extension 목록 가져오기
+     */
+    getClientExtensions(point: ExtensionPoint): ClientExtensionConfig[];
+    /**
+     * 모든 Client Extension 정보 가져오기 (디버깅용)
+     */
+    getAllClientExtensions(): Map<ExtensionPoint, ClientExtensionConfig[]>;
+}

package/dist/listgrid/config/form/EntityFormExtensions.js

@@ -0,0 +1,105 @@
+import { ExtensionPoint, } from '../../extensions/EntityFormExtension.types';
+import { EntityFormActions } from '../../config/form/EntityFormActions';
+export class EntityFormExtensions extends EntityFormActions {
+    constructor(name, url) {
+        super(name, url);
+    }
+    /**
+     * Client Extension 추가 메소드 (내부용)
+     */
+    withClientExtension(point, handler, options) {
+        const config = {
+            handler,
+            options: {
+                enabled: true,
+                continueOnError: true,
+                priority: 0,
+                ...options,
+            },
+        };
+        const configs = this.clientExtensions.get(point) || [];
+        configs.push(config);
+        // priority로 정렬
+        configs.sort((a, b) => (a.options?.priority || 0) - (b.options?.priority || 0));
+        this.clientExtensions.set(point, configs);
+        return this;
+    }
+    // LIST Extensions - Client
+    withClientPreFetchList(handler, options) {
+        return this.withClientExtension(ExtensionPoint.PRE_FETCH_LIST, handler, options);
+    }
+    withClientPostFetchList(handler, options) {
+        return this.withClientExtension(ExtensionPoint.POST_FETCH_LIST, handler, options);
+    }
+    // CREATE Extensions - Client
+    withClientPreCreate(handler, options) {
+        return this.withClientExtension(ExtensionPoint.PRE_CREATE, handler, options);
+    }
+    withClientPostCreate(handler, options) {
+        return this.withClientExtension(ExtensionPoint.POST_CREATE, handler, options);
+    }
+    // READ Extensions - Client
+    withClientPreRead(handler, options) {
+        return this.withClientExtension(ExtensionPoint.PRE_READ, handler, options);
+    }
+    withClientPostRead(handler, options) {
+        return this.withClientExtension(ExtensionPoint.POST_READ, handler, options);
+    }
+    // UPDATE Extensions - Client
+    withClientPreUpdate(handler, options) {
+        return this.withClientExtension(ExtensionPoint.PRE_UPDATE, handler, options);
+    }
+    withClientPostUpdate(handler, options) {
+        return this.withClientExtension(ExtensionPoint.POST_UPDATE, handler, options);
+    }
+    // DELETE Extensions - Client
+    withClientPreDelete(handler, options) {
+        return this.withClientExtension(ExtensionPoint.PRE_DELETE, handler, options);
+    }
+    withClientPostDelete(handler, options) {
+        return this.withClientExtension(ExtensionPoint.POST_DELETE, handler, options);
+    }
+    /**
+     * Client Extension 실행
+     */
+    async executeClientExtensions(point, data, context) {
+        const configs = this.clientExtensions.get(point) || [];
+        let result = data;
+        for (const config of configs) {
+            // 비활성화된 Extension은 건너뛰기
+            if (config.options?.enabled === false)
+                continue;
+            try {
+                result = await config.handler(result, context);
+            }
+            catch (error) {
+                console.error(`[Client Extension Error] ${this.name}.${point}:`, error);
+                if (config.options?.continueOnError === false) {
+                    throw error;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Client Extensions 존재 여부 확인
+     */
+    hasClientExtensions(...points) {
+        return points.some((point) => {
+            const clientConfigs = this.clientExtensions.get(point) || [];
+            return clientConfigs.length > 0;
+        });
+    }
+    /**
+     * 특정 Extension Point의 Client Extension 목록 가져오기
+     */
+    getClientExtensions(point) {
+        return this.clientExtensions.get(point) || [];
+    }
+    /**
+     * 모든 Client Extension 정보 가져오기 (디버깅용)
+     */
+    getAllClientExtensions() {
+        return new Map(this.clientExtensions);
+    }
+}

package/dist/listgrid/config/form/EntityFormValidation.d.ts

@@ -0,0 +1,28 @@
+import { EntityFormBase } from '../../config/form/EntityFormBase';
+import { FieldError } from '../../config/EntityFormTypes';
+import { ManageEntityForm } from '../../config/Config';
+export declare abstract class EntityFormValidation<T extends object = any> extends EntityFormBase<T> {
+    constructor(name: string, url: string);
+    getFieldValidationState(fieldName: string): {
+        validated: boolean;
+        message?: string;
+        color?: string;
+    } | undefined;
+    setFieldValidationState(fieldName: string, state: {
+        validated: boolean;
+        message?: string;
+        color?: string;
+    }): void;
+    clearFieldValidationState(fieldName: string): void;
+    withRequired(name: string, required: boolean): this;
+    withErrors(errors: FieldError[]): this;
+    getErrorMap(): Map<string, FieldError[]>;
+    mergeError(name: string, errors: FieldError[]): void;
+    withManageEntityForm(manageEntityForm: ManageEntityForm): this;
+    withCreatable(creatable?: boolean): this;
+    withUpdatable(updatable?: boolean): this;
+    withDeletable(deletable?: boolean): this;
+    isCreatable(): boolean;
+    isUpdatable(): boolean;
+    isDeletable(): boolean;
+}

package/dist/listgrid/config/form/EntityFormValidation.js

@@ -0,0 +1,128 @@
+import { EntityFormBase } from '../../config/form/EntityFormBase';
+import { isEmpty } from '../../utils';
+import { mergeFieldErrors } from '../../config/EntityFormMethod';
+export class EntityFormValidation extends EntityFormBase {
+    constructor(name, url) {
+        super(name, url);
+    }
+    getFieldValidationState(fieldName) {
+        return this.fieldValidationStates.get(fieldName);
+    }
+    setFieldValidationState(fieldName, state) {
+        this.fieldValidationStates.set(fieldName, state);
+    }
+    clearFieldValidationState(fieldName) {
+        this.fieldValidationStates.delete(fieldName);
+    }
+    withRequired(name, required) {
+        const field = this.getField(name);
+        if (field) {
+            this.fields.set(name, field.withRequired(required));
+        }
+        return this;
+    }
+    withErrors(errors) {
+        this.errors = errors;
+        return this;
+    }
+    getErrorMap() {
+        const errorMap = new Map();
+        if (!isEmpty(this.errors)) {
+            for (const error of this.errors) {
+                const fieldName = error.name;
+                // 이 필드가 속한 Tab 을 확인한다.
+                const field = this.getField(fieldName);
+                const tabId = field?.getTabId();
+                if (tabId) {
+                    const tab = this.getTab(tabId);
+                    if (tab) {
+                        const key = tab.label;
+                        const fieldErrors = errorMap.get(key);
+                        if (fieldErrors) {
+                            let duplicated = false;
+                            for (const err of fieldErrors) {
+                                if (err.name === error.name) {
+                                    duplicated = true;
+                                    for (const message of err.errors) {
+                                        if (!error.errors.includes(message)) {
+                                            error.errors.push(message);
+                                        }
+                                    }
+                                    err.errors = error.errors;
+                                    break;
+                                }
+                            }
+                            if (!duplicated) {
+                                // tabId를 error 객체에 추가
+                                error.tabId = tabId;
+                                fieldErrors.push(error);
+                            }
+                        }
+                        else {
+                            // tabId를 error 객체에 추가
+                            error.tabId = tabId;
+                            errorMap.set(key, [error]);
+                        }
+                    }
+                }
+            }
+        }
+        return errorMap;
+    }
+    mergeError(name, errors) {
+        if (this.errors === undefined) {
+            this.errors = errors;
+        }
+        else {
+            if (errors !== undefined && errors.length > 0) {
+                const newErrors = [];
+                for (const error of this.errors) {
+                    if (error.name !== name) {
+                        newErrors.push(error);
+                    }
+                    else {
+                        // 기존과 같은 이름을 가진 error 가 존재했다면 병합하고 끝낸다.
+                        this.errors = mergeFieldErrors(this.errors, errors);
+                        return;
+                    }
+                }
+                newErrors.push(...errors);
+                this.errors = newErrors;
+            }
+            else {
+                const newErrors = [];
+                for (const error of this.errors) {
+                    if (error.name !== name) {
+                        newErrors.push(error);
+                    }
+                }
+                this.errors = newErrors;
+            }
+        }
+    }
+    withManageEntityForm(manageEntityForm) {
+        this.manageEntityForm = manageEntityForm;
+        return this;
+    }
+    withCreatable(creatable = true) {
+        this.manageEntityForm.create = creatable;
+        return this;
+    }
+    withUpdatable(updatable = true) {
+        this.manageEntityForm.update = updatable;
+        return this;
+    }
+    withDeletable(deletable = true) {
+        this.manageEntityForm.delete = deletable;
+        return this;
+    }
+    isCreatable() {
+        return this.manageEntityForm.create;
+    }
+    isUpdatable() {
+        return this.manageEntityForm.update;
+    }
+    isDeletable() {
+        return this.manageEntityForm.delete;
+    }
+}

package/dist/listgrid/extensions/EntityFormExtension.types.d.ts

@@ -0,0 +1,52 @@
+import { Session } from '../auth/types';
+import { EntityForm } from '../config/EntityForm';
+/**
+ * Extension Context - Client에서 사용 가능한 정보
+ * 제네릭 Session 타입 사용 - 프로젝트별로 구체 타입 확장 가능
+ */
+export interface ClientExtensionContext<TSession = Session, TUser = any> {
+    session?: TSession;
+    user?: TUser;
+    entityForm: EntityForm;
+    [key: string]: any;
+}
+/**
+ * Extension 실행 옵션
+ */
+export interface ExtensionOptions {
+    /** 실행 우선순위 (낮은 숫자가 먼저 실행됨) */
+    priority?: number;
+    /** Extension 활성화 여부 (기본값: true) */
+    enabled?: boolean;
+    /** 에러 발생 시 계속 진행할지 여부 (기본값: true) */
+    continueOnError?: boolean;
+    /** Extension 설명 */
+    description?: string;
+}
+/**
+ * Client Extension 함수 타입 - EntityForm 접근 가능
+ */
+export type ClientExtensionFunction<TInput, TOutput = TInput> = (data: TInput, context: ClientExtensionContext) => Promise<TOutput> | TOutput;
+/**
+ * Extension Point 정의
+ * 클라이언트와 서버 모두에서 사용되는 공통 enum
+ */
+export declare enum ExtensionPoint {
+    PRE_FETCH_LIST = "preFetchList",
+    POST_FETCH_LIST = "postFetchList",
+    PRE_CREATE = "preCreate",
+    POST_CREATE = "postCreate",
+    PRE_READ = "preRead",
+    POST_READ = "postRead",
+    PRE_UPDATE = "preUpdate",
+    POST_UPDATE = "postUpdate",
+    PRE_DELETE = "preDelete",
+    POST_DELETE = "postDelete"
+}
+/**
+ * Client Extension 설정
+ */
+export interface ClientExtensionConfig {
+    handler: ClientExtensionFunction<any>;
+    options?: Omit<ExtensionOptions, 'executionContext'>;
+}

package/dist/listgrid/extensions/EntityFormExtension.types.js

@@ -0,0 +1,19 @@
+/**
+ * Extension Point 정의
+ * 클라이언트와 서버 모두에서 사용되는 공통 enum
+ */
+export var ExtensionPoint;
+(function (ExtensionPoint) {
+    // LIST 관련
+    ExtensionPoint["PRE_FETCH_LIST"] = "preFetchList";
+    ExtensionPoint["POST_FETCH_LIST"] = "postFetchList";
+    // CRUD 관련
+    ExtensionPoint["PRE_CREATE"] = "preCreate";
+    ExtensionPoint["POST_CREATE"] = "postCreate";
+    ExtensionPoint["PRE_READ"] = "preRead";
+    ExtensionPoint["POST_READ"] = "postRead";
+    ExtensionPoint["PRE_UPDATE"] = "preUpdate";
+    ExtensionPoint["POST_UPDATE"] = "postUpdate";
+    ExtensionPoint["PRE_DELETE"] = "preDelete";
+    ExtensionPoint["POST_DELETE"] = "postDelete";
+})(ExtensionPoint || (ExtensionPoint = {}));

package/dist/listgrid/extensions/FieldExtensions.d.ts

@@ -0,0 +1,5 @@
+export interface SmsHistoryFieldConstructor {
+    new (fieldName: string, order: number, targetFieldName: string): any;
+}
+export declare function registerSmsHistoryField(ctor: SmsHistoryFieldConstructor): void;
+export declare function createSmsHistoryField(fieldName: string, order: number, targetFieldName: string): any | null;

package/dist/listgrid/extensions/FieldExtensions.js

@@ -0,0 +1,21 @@
+// Stage 3 — Host-supplied domain field extension registry.
+//
+// The original library hard-wired `SmsHistoryField` (an academic-system
+// domain artifact from a separate entities module) directly in EntityForm.tsx. A truly
+// reusable library cannot assume SMS history exists; instead host apps
+// register their own SMS-history-like field implementation here.
+//
+// If no host implementation is registered, the SMS history behaviour is
+// silently skipped — callers should check `createSmsHistoryField` for null.
+let _smsHistoryFieldCtor;
+export function registerSmsHistoryField(ctor) {
+    _smsHistoryFieldCtor = ctor;
+}
+export function createSmsHistoryField(fieldName, order, targetFieldName) {
+    if (!_smsHistoryFieldCtor) {
+        console.warn('[@rchemist/listgrid] SMS history field requested but no implementation registered. ' +
+            'Call registerSmsHistoryField(YourSmsHistoryFieldClass) at bootstrap.');
+        return null;
+    }
+    return new _smsHistoryFieldCtor(fieldName, order, targetFieldName);
+}