@rchemist/listgrid 0.2.6

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

@@ -0,0 +1,43 @@
+import { ModifyEntityFormFunc } from '../config/Config';
+import { Validation } from '../validations/Validation';
+import { SelectOption } from '../form/Type';
+export type ConditionalProps = {
+    value: any;
+    result: Map<string, boolean>;
+};
+export type ConditionalSelectOptionProps = {
+    value: any;
+    result: Map<string, SelectOption[]>;
+    defaultValue?: any;
+};
+export type OptionalValidation = false | {
+    type?: 'append' | 'overwrite';
+    validations?: Validation[];
+};
+export type ConditionalValidations = {
+    value: ConditionalValidationValue;
+    result: Map<string, OptionalValidation>;
+};
+export type ConditionalValidationValue = string | number | boolean | string[] | number[] | boolean[] | ((value: any) => boolean);
+export declare class ConditionalValidation implements ConditionalValidations {
+    value: ConditionalValidationValue;
+    result: Map<string, OptionalValidation>;
+    constructor(value: ConditionalValidationValue);
+    static create(value: ConditionalValidationValue): ConditionalValidation;
+    addValidation(fieldName: string, type: 'append' | 'overwrite', ...validations: Validation[]): this;
+}
+export declare class ConditionalSelectOption implements ConditionalSelectOptionProps {
+    value: any;
+    result: Map<string, SelectOption[]>;
+    defaultValue: any;
+    constructor(value: any);
+    static create(value: any): ConditionalSelectOption;
+    withDefaultValue(defaultValue?: any): this;
+    addSelectOption(fieldName: string, ...options: SelectOption[]): this;
+}
+export declare class OnChangeEntityForm {
+    static changeHidden(name: string, options: ConditionalProps | ConditionalProps[]): ModifyEntityFormFunc;
+    static changeRequired(name: string, options: ConditionalProps | ConditionalProps[]): ModifyEntityFormFunc;
+    static changeSelectOptions(name: string, options: ConditionalSelectOptionProps | ConditionalSelectOptionProps[]): ModifyEntityFormFunc;
+    static derivedValidations(name: string, options: ConditionalValidations | ConditionalValidations[]): ModifyEntityFormFunc;
+}

package/dist/listgrid/config/OnChangeEntityForm.js

@@ -0,0 +1,266 @@
+import { OptionalField } from '../components/fields/abstract';
+export class ConditionalValidation {
+    constructor(value) {
+        this.result = new Map();
+        this.value = value;
+    }
+    static create(value) {
+        return new ConditionalValidation(value);
+    }
+    addValidation(fieldName, type, ...validations) {
+        this.result.set(fieldName, { type, validations });
+        return this;
+    }
+}
+export class ConditionalSelectOption {
+    constructor(value) {
+        this.result = new Map();
+        this.value = value;
+    }
+    static create(value) {
+        return new ConditionalSelectOption(value);
+    }
+    withDefaultValue(defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+    addSelectOption(fieldName, ...options) {
+        this.result.set(fieldName, options);
+        return this;
+    }
+}
+export class OnChangeEntityForm {
+    static changeHidden(name, options) {
+        return onChangeSetFieldHidden(name, options);
+    }
+    static changeRequired(name, options) {
+        return onChangeSetFieldRequired(name, options);
+    }
+    static changeSelectOptions(name, options) {
+        return onChangeSetSelectOptions(name, options);
+    }
+    static derivedValidations(name, options) {
+        return onChangeDerivedValidations(name, options);
+    }
+}
+function onChangeDerivedValidations(name, options) {
+    return (entityForm) => {
+        const field = entityForm.getField(name);
+        if (field) {
+            const value = field.getCurrentValue(entityForm.getRenderType());
+            if (Array.isArray(options)) {
+                for (const option of options) {
+                    setDerivedValidations(option, value);
+                }
+            }
+            else {
+                setDerivedValidations(options, value, true);
+            }
+        }
+        return Promise.resolve(entityForm);
+        function setDerivedValidations(option, value, autoRemove = false) {
+            function isMatched(option, value) {
+                if (typeof option.value === 'function') {
+                    return option.value(value);
+                }
+                return option.value === value;
+            }
+            if (isMatched(option, value)) {
+                option.result.forEach((value, key) => {
+                    const f = entityForm.getField(key);
+                    if (f) {
+                        // false 로 지정하면 validations 을 제거하라는 뜻이다.
+                        if (value === false) {
+                            f.withValidations();
+                        }
+                        else {
+                            if (value.type === 'overwrite') {
+                                const validations = value.validations ? [...value.validations] : [];
+                                f.withValidations(...validations);
+                            }
+                            else {
+                                const validations = f.validations ? [...f.validations] : [];
+                                if (value.validations) {
+                                    for (const v of value.validations) {
+                                        let duplicated = false;
+                                        for (const validation of [...validations]) {
+                                            if (validation.id === v.id) {
+                                                duplicated = true;
+                                            }
+                                        }
+                                        if (!duplicated) {
+                                            validations.push(v);
+                                        }
+                                    }
+                                }
+                                f.withValidations(...validations);
+                            }
+                        }
+                    }
+                });
+            }
+            else {
+                if (autoRemove) {
+                    option.result.forEach((value, key) => {
+                        const f = entityForm.getField(key);
+                        if (f && f.validations) {
+                            const validations = [...f.validations];
+                            if (typeof value === 'boolean') {
+                                f.withValidations();
+                            }
+                            else {
+                                if (value.validations) {
+                                    for (const validation of validations) {
+                                        for (const v of value.validations) {
+                                            if (validation.id === v.id) {
+                                                validations.splice(validations.indexOf(validation), 1);
+                                            }
+                                        }
+                                    }
+                                    f.withValidations(...validations);
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    };
+}
+function onChangeSetSelectOptions(name, options) {
+    function changeOptions({ key, field, value, entityForm, defaultValue, }) {
+        if (key === field.getName()) {
+            if (field instanceof OptionalField) {
+                return field.changeOptions(value);
+            }
+        }
+        else {
+            const other = entityForm.getField(key);
+            if (other instanceof OptionalField) {
+                return other.changeOptions(value, defaultValue);
+            }
+        }
+        return false;
+    }
+    function revertOptions(key, field, entityForm) {
+        if (key === field.getName()) {
+            if (field instanceof OptionalField) {
+                return field.revertOptions(entityForm.getRenderType());
+            }
+        }
+        else {
+            const other = entityForm.getField(key);
+            if (other instanceof OptionalField) {
+                return other.revertOptions(entityForm.getRenderType());
+            }
+        }
+        return false;
+    }
+    return (entityForm) => {
+        const field = entityForm.getField(name);
+        let changed = false;
+        if (field) {
+            const value = field.getCurrentValue(entityForm.getRenderType());
+            if (Array.isArray(options)) {
+                for (const option of options) {
+                    if (option.value === value) {
+                        option.result.forEach((value, key) => {
+                            if (changeOptions({ key, field, value, entityForm })) {
+                                changed = true;
+                            }
+                        });
+                    }
+                    else {
+                        option.result.forEach((_value, key) => {
+                            if (revertOptions(key, field, entityForm)) {
+                                changed = true;
+                            }
+                        });
+                    }
+                }
+            }
+            else {
+                if (options.value === value) {
+                    options.result.forEach((value, key) => {
+                        if (changeOptions({ key, field, value, entityForm })) {
+                            changed = true;
+                        }
+                    });
+                }
+                else {
+                    options.result.forEach((_value, key) => {
+                        if (revertOptions(key, field, entityForm)) {
+                            changed = true;
+                        }
+                    });
+                }
+            }
+        }
+        if (changed) {
+            entityForm.withShouldReload(changed);
+        }
+        return Promise.resolve(entityForm);
+    };
+}
+function onChangeSetFieldRequired(name, options) {
+    return (entityForm) => {
+        const field = entityForm.getField(name);
+        if (field) {
+            const value = field.getCurrentValue(entityForm.getRenderType());
+            if (Array.isArray(options)) {
+                for (const prop of options) {
+                    if (prop.value === value) {
+                        prop.result.forEach((value, key) => {
+                            entityForm.getField(key)?.withRequired(value);
+                        });
+                    }
+                }
+            }
+            else {
+                // option 이 단수라면 value 가 equals 일 때와 그렇지 않을 때를 각각 적용한다.
+                const required = value === options.value;
+                options.result.forEach((v, k) => {
+                    const requiredValue = required ? v : !v;
+                    if (k === field.getName()) {
+                        field.withRequired(requiredValue);
+                    }
+                    else {
+                        entityForm.getField(k)?.withRequired(requiredValue);
+                    }
+                });
+            }
+        }
+        return Promise.resolve(entityForm);
+    };
+}
+function onChangeSetFieldHidden(name, options) {
+    return (entityForm) => {
+        const field = entityForm.getField(name);
+        if (field) {
+            const value = field.getCurrentValue(entityForm.getRenderType());
+            if (Array.isArray(options)) {
+                for (const prop of options) {
+                    if (prop.value === value) {
+                        prop.result.forEach((value, key) => {
+                            entityForm.getField(key)?.withHidden(value);
+                        });
+                    }
+                }
+            }
+            else {
+                // option 이 단수라면 value 가 equals 일 때와 그렇지 않을 때를 각각 적용한다.
+                const hidden = value === options.value;
+                options.result.forEach((v, k) => {
+                    const hiddenValue = hidden ? v : !v;
+                    if (k === field.getName()) {
+                        field.withHidden(hiddenValue);
+                    }
+                    else {
+                        entityForm.getField(k)?.withHidden(hiddenValue);
+                    }
+                });
+            }
+        }
+        return Promise.resolve(entityForm);
+    };
+}

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

@@ -0,0 +1,18 @@
+export interface RuntimeConfig {
+    /** Enables server-side-rendered list caching hints. */
+    cacheControl?: boolean;
+    /** Enables an alternate listgrid data pipeline (server-side cache). */
+    useServerSideCache?: boolean;
+    /** sessionStorage key prefix for SearchForm persistence. */
+    searchFormHashKey?: string;
+    /** Performance logging toggle for the listgrid engine. */
+    debugListGridPerformance?: boolean;
+    /** True when NODE_ENV === 'development' (used by perf logger). */
+    isDevelopment?: boolean;
+    /** Kakao Maps JS SDK app key. */
+    kakaoMapAppKey?: string;
+    /** simpleCrypt passphrase / secret (replaces NEXT_PUBLIC_CRYPT_KEY). */
+    cryptKey?: string;
+}
+export declare function configureRuntime(config: RuntimeConfig): void;
+export declare function getRuntimeConfig(): Required<RuntimeConfig>;

package/dist/listgrid/config/RuntimeConfig.js

@@ -0,0 +1,22 @@
+// Stage 8 — runtime configuration.
+//
+// Replaces hard-coded `process.env.NEXT_PUBLIC_*` access with a
+// framework-agnostic registry. Host apps call `configureRuntime({...})`
+// at bootstrap with their platform-specific values (from Next env vars,
+// Vite import.meta.env, custom config, etc.).
+const DEFAULT = {
+    cacheControl: false,
+    useServerSideCache: false,
+    searchFormHashKey: 'rcm-searchform',
+    debugListGridPerformance: false,
+    isDevelopment: false,
+    kakaoMapAppKey: '',
+    cryptKey: '',
+};
+let _config = { ...DEFAULT };
+export function configureRuntime(config) {
+    _config = { ...DEFAULT, ..._config, ...config };
+}
+export function getRuntimeConfig() {
+    return _config;
+}

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

@@ -0,0 +1,119 @@
+import { EntityItem } from '../config/EntityItem';
+import { EntityForm } from '../config/EntityForm';
+import { ConditionalReactNodeValue, HelpTextType, HiddenType, LabelType, ManyToOneFilter, OptionalBoolean, ReadOnlyType, ViewPreset } from '../config/Config';
+import { ListGrid } from '../config/ListGrid';
+import { ReactNode } from 'react';
+import { ViewListGridOptionProps } from '../components/list/types/ViewListGrid.types';
+import { FilterItem } from '../form/SearchForm';
+import { FieldInfoParameters } from './EntityField';
+import { Session } from '../auth/types';
+export declare class SubCollectionField implements EntityItem {
+    order: number;
+    name: string;
+    label?: LabelType | undefined;
+    helpText?: HelpTextType | undefined;
+    hidden?: HiddenType | undefined;
+    readonly?: ReadOnlyType | undefined;
+    dynamicUrl?: ((parentEntityForm: EntityForm) => string) | undefined;
+    form?: {
+        tabId: string;
+        fieldGroupId: string;
+    } | undefined;
+    entityForm: EntityForm;
+    hideLabel?: boolean | undefined;
+    relation: SubCollectionRelation;
+    listViewFields?: string[] | undefined;
+    viewListOptions?: ViewListGridOptionProps | undefined;
+    constructor(props: {
+        entityForm: EntityForm;
+        relation: SubCollectionRelation;
+        order: number;
+        name: string;
+        label?: LabelType | undefined;
+        helpText?: HelpTextType | undefined;
+        hidden?: HiddenType | undefined;
+        readonly?: ReadOnlyType | undefined;
+        dynamicUrl?: ((parentEntityForm: EntityForm) => string) | undefined;
+        viewListOptions?: ViewListGridOptionProps | undefined;
+    });
+    withTooltip(tooltip?: ConditionalReactNodeValue): this;
+    clone(): SubCollectionField;
+    getTabId(): string;
+    getFieldGroupId(): string;
+    withTabId(tabId: string): this;
+    withFieldGroupId(fieldGroupId: string): this;
+    withHelpText(helpText?: HelpTextType): this;
+    withHidden(hidden?: boolean | OptionalBoolean): this;
+    withLabel(label?: LabelType): this;
+    withReadOnly(readOnly?: boolean | OptionalBoolean): this;
+    withHideLabel(hideLabel?: boolean): this;
+    withOrder(order: number): this;
+    withViewListGridOptionProps(props: ViewListGridOptionProps): this;
+    getViewListGridOptionProps(): ViewListGridOptionProps;
+    getOrder(): number;
+    getName(): string;
+    getLabel(): LabelType;
+    getHelpText(props: FieldInfoParameters): Promise<ReactNode>;
+    isHidden(props: FieldInfoParameters): Promise<boolean>;
+    isReadonly(props: FieldInfoParameters): Promise<boolean>;
+    withForm(form: {
+        tabId: string;
+        fieldGroupId: string;
+    }): this;
+    withViewPreset(type: ViewPreset): this;
+    withListViewFields(...listViewFields: string[]): this;
+    withDynamicUrl(props: (parentEntityForm: EntityForm) => string): this;
+    getListGrid(parentEntityForm: EntityForm): ListGrid;
+    render({ entityForm, session, }: {
+        entityForm: EntityForm;
+        session?: Session;
+    }): Promise<ReactNode | null>;
+    protected getMappedByFilter(entityForm: EntityForm): FilterItem;
+    protected getMappedByValue(entityForm: EntityForm): string | number | undefined;
+}
+interface SubCollectionRelation {
+    /**
+     * Create/Update Form 전송 시 부모 엔티티 ID를 담을 필드명.
+     *
+     * [주의] JPA의 @ManyToOne mappedBy와 다른 개념입니다!
+     *
+     * - 용도: 백엔드 CreateForm/UpdateForm에 전송되는 필드명
+     * - 형식: 보통 'parentEntityId' 형태 (예: 'practiceId', 'syllabusId')
+     * - 조회 필터 변환: 'xxxId' 형태면 자동으로 'xxx.id'로 변환되어 조회 필터에 사용됨
+     *
+     * 예시:
+     * - mappedBy: 'practiceId' → Create 시 { practiceId: '...' } 전송
+     *                          → 조회 시 practice.id 필터로 자동 변환
+     */
+    mappedBy: string;
+    /**
+     * 조회 필터에 사용할 필드명 (선택사항).
+     *
+     * - 용도: 서브 콜렉션 목록 조회 시 부모 ID로 필터링할 필드명
+     * - 형식: 보통 'entity.id' 형태 (예: 'practice.id', 'syllabus.id')
+     * - 미지정 시: mappedBy가 'xxxId' 형태면 자동으로 'xxx.id'로 변환
+     *
+     * 명시적 지정이 필요한 경우:
+     * - mappedBy와 다른 필드명으로 조회해야 할 때
+     * - 자동 변환 규칙이 맞지 않을 때
+     */
+    filterBy?: string;
+    /**
+     * 부모 엔티티에서 mappedBy 값으로 사용할 프로퍼티명.
+     *
+     * - 미지정 시: 부모 entityForm의 'id' 사용
+     * - 지정 시: 부모 entityForm에서 해당 프로퍼티 값 사용
+     */
+    valueProperty?: string;
+    /**
+     * 서브콜렉션 내부에서 사용할 추가 속성.
+     *
+     * 예: 서브콜렉션 내 ManyToOneField의 필터에 최상위 엔티티 값이 필요할 때
+     * (Syllabus - SyllabusPrivileged 관계에서 admission 필터가 syllabus.id일 때 등)
+     */
+    attributes?: Record<string, any>;
+    subCollectionEntityForm?: {
+        manyToOneFilter?: Record<string, ManyToOneFilter[]>;
+    };
+}
+export {};