@rchemist/listgrid 0.2.6

package/dist/listgrid/config/CardSubCollectionField.js

@@ -0,0 +1,164 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getConditionalReactNode, } from './Config';
+import React from 'react';
+import { SearchForm } from '../form/SearchForm';
+import { SubCollectionField } from './SubCollectionField';
+/**
+ * CardSubCollectionField configuration
+ * Extends SubCollectionField to display items in a card grid format
+ */
+export class CardSubCollectionField extends SubCollectionField {
+    constructor(props) {
+        // Call parent constructor
+        super({
+            entityForm: props.entityForm,
+            relation: props.relation,
+            order: props.order,
+            name: props.name,
+            label: props.label,
+            helpText: props.helpText,
+            hidden: props.hidden,
+            readonly: props.readonly,
+        });
+        // Set default fetchOptions (same as SubCollectionField behavior)
+        // Default: useSearchForm: true, viewDetail: true, pageSize: 10000
+        const defaultFetchOptions = {
+            useSearchForm: true,
+            viewDetail: true,
+            pageSize: 10000,
+        };
+        // Merge user-provided fetchOptions with defaults
+        this.fetchOptions = props.fetchOptions
+            ? { ...defaultFetchOptions, ...props.fetchOptions }
+            : defaultFetchOptions;
+        // Handle fetchUrl - can be string or function
+        // When useSearchForm is true (default), use the entityForm's URL
+        if (this.fetchOptions.useSearchForm) {
+            this.fetchUrl = props.entityForm.getUrl();
+        }
+        else if (typeof props.fetchUrl === 'function') {
+            this.fetchUrl = props.entityForm.getUrl(); // Default to entityForm URL
+            this.fetchUrlFunction = props.fetchUrl;
+        }
+        else {
+            this.fetchUrl = props.fetchUrl ?? props.entityForm.getUrl();
+        }
+        this.cardConfig = props.cardConfig;
+    }
+    /**
+     * Override withTooltip to support tooltips (parent class doesn't support it)
+     */
+    withTooltip(tooltip) {
+        this.tooltip = tooltip;
+        return this;
+    }
+    async getTooltip(props) {
+        return await getConditionalReactNode(props, this.tooltip);
+    }
+    /**
+     * Override clone to include card-specific properties
+     */
+    clone() {
+        const cloned = new CardSubCollectionField({
+            entityForm: this.entityForm,
+            relation: this.relation,
+            order: this.order,
+            name: this.name,
+            label: this.label,
+            helpText: this.helpText,
+            hidden: this.hidden,
+            readonly: this.readonly,
+            fetchUrl: this.fetchUrl,
+            cardConfig: this.cardConfig,
+            fetchOptions: this.fetchOptions,
+        });
+        cloned.form = this.form;
+        cloned.hideLabel = this.hideLabel;
+        cloned.tooltip = this.tooltip;
+        return cloned;
+    }
+    withFetchOptions(fetchOptions) {
+        // Merge with existing fetchOptions (which already has defaults)
+        this.fetchOptions = { ...this.fetchOptions, ...fetchOptions };
+        return this;
+    }
+    withCardConfig(cardConfig) {
+        this.cardConfig = cardConfig;
+        return this;
+    }
+    /**
+     * Build the SearchForm for fetching data
+     * Note: getMappedByFilter() and getMappedByValue() are inherited from SubCollectionField
+     */
+    async buildSearchForm(parentEntityForm) {
+        const searchForm = new SearchForm();
+        // Set page size (default: 10000 to fetch all data at once)
+        searchForm.withPageSize(this.fetchOptions?.pageSize ?? 10000);
+        // Set viewDetail mode
+        if (this.fetchOptions?.viewDetail) {
+            searchForm.withViewDetail(true);
+        }
+        // Get the mappedBy filter
+        const mappedByFilter = this.getMappedByFilter(parentEntityForm);
+        // Apply user-defined filters if any
+        if (this.fetchOptions?.filters) {
+            const additionalFilters = await this.fetchOptions.filters(parentEntityForm);
+            if (additionalFilters.length > 0 && additionalFilters[0].items) {
+                // Check if mappedBy filter already exists
+                const hasMappedByFilter = additionalFilters[0].items.some((item) => item.name === mappedByFilter.name);
+                if (!hasMappedByFilter) {
+                    additionalFilters[0].items.unshift(mappedByFilter);
+                }
+                // Apply all filters
+                additionalFilters.forEach((filterGroup) => {
+                    searchForm.withFilter(filterGroup.condition, ...filterGroup.items);
+                });
+            }
+        }
+        else {
+            // Apply only mappedBy filter
+            searchForm.handleAndFilter(mappedByFilter.name, mappedByFilter.value);
+        }
+        return searchForm;
+    }
+    /**
+     * Override render to display card grid instead of list grid
+     */
+    async render({ entityForm, session, }) {
+        // Lazy load the CardSubCollectionView component
+        const CardSubCollectionView = React.lazy(() => import('../components/list/ui/CardSubCollectionView').then((m) => ({
+            default: m.CardSubCollectionView,
+        })));
+        // Get the fetch URL
+        let fetchUrl;
+        if (this.fetchUrlFunction) {
+            fetchUrl = this.fetchUrlFunction(entityForm);
+        }
+        else {
+            fetchUrl = this.fetchUrl;
+        }
+        // Determine readonly status
+        const readonly = await this.isReadonly({ entityForm, session });
+        // Get tooltip
+        const tooltip = await this.getTooltip({ entityForm, session });
+        // Build initial SearchForm if using SearchForm-based fetching
+        let initialSearchForm;
+        if (this.fetchOptions?.useSearchForm) {
+            initialSearchForm = await this.buildSearchForm(entityForm);
+        }
+        const viewProps = {
+            parentEntityForm: entityForm,
+            parentId: entityForm.id,
+            entityForm: this.entityForm,
+            fetchUrl,
+            ...(this.cardConfig !== undefined ? { cardConfig: this.cardConfig } : {}),
+            relation: this.relation,
+            readonly,
+            ...(session !== undefined ? { session } : {}),
+            ...(this.fetchOptions !== undefined ? { fetchOptions: this.fetchOptions } : {}),
+            ...(initialSearchForm !== undefined ? { initialSearchForm } : {}),
+            tooltip,
+        };
+        return (_jsx(React.Suspense, { fallback: _jsx("div", { className: "rcm-loading-overlay", children: _jsx("div", { className: "rcm-spinner" }) }), children: _jsx(CardSubCollectionView, { ...viewProps }) }));
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SelectOption } from '../form/Type';
+export declare const AdjustmentTypes: SelectOption[];
+export type AdjustmentType = 'FIXED_PRICE' | 'ADD_AMOUNT' | 'ADD_PERCENT' | 'OFF_AMOUNT' | 'OFF_PERCENT';
+export declare function getAdjustmentTypeLabel(adjustmentType: AdjustmentType): string;

package/dist/listgrid/config/CommonType.js

@@ -0,0 +1,15 @@
+export const AdjustmentTypes = [
+    { label: '고정 가격', value: 'FIXED_PRICE' },
+    { label: '금액 추가', value: 'ADD_AMOUNT' },
+    { label: '비율 추가', value: 'ADD_PERCENT' },
+    { label: '금액 할인', value: 'OFF_AMOUNT' },
+    { label: '비율 할인', value: 'OFF_PERCENT' },
+];
+export function getAdjustmentTypeLabel(adjustmentType) {
+    for (const type of AdjustmentTypes) {
+        if (type.value === adjustmentType) {
+            return type.label ?? type.value;
+        }
+    }
+    return adjustmentType;
+}

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

@@ -0,0 +1,251 @@
+import React, { ReactNode } from 'react';
+import { EntityForm } from '../config/EntityForm';
+import { FilterItem, SearchValue } from '../form/SearchForm';
+import { IListConfig } from '../components/fields/abstract';
+import { MinMaxLimit, SelectOption } from '../form/Type';
+import { TreeNodeData } from '../ui';
+import { Session } from '../auth/types';
+import { ValidateResult } from '../validations/Validation';
+export type FieldType = 'text' | 'number' | 'date' | 'datetime' | 'boolean' | 'select' | 'manyToOne' | 'email' | 'phone' | 'time' | 'month' | 'tag' | 'file' | 'year' | 'checkbox' | 'multiselect' | 'textarea' | 'password' | 'image' | 'html' | 'markdown' | 'inlineMap' | 'hidden' | 'custom' | 'xrefMapping' | 'xrefPriorityMapping' | 'xrefAvailableMapping' | 'revision' | 'contentAsset';
+/**
+ * LabelType 에 따라 라벨 표시 방법이 달라진다.
+ * string 은 i18n 으로 라벨 처리
+ * ReactNode 면 단순 표시
+ * false 면 표시하지 않는다.
+ */
+export type LabelType = string | ReactNode | false;
+export type PermissionType = 'ALL' | 'READ' | 'NONE';
+/**
+ * EntityForm 을 화면에 출력할 때 create 상황인지, update 상황인지에 대한 분기 처리를 위한 값
+ */
+export type RenderType = 'create' | 'update';
+export type ConditionalReactNodeValue = ReactNode | OptionalReactNode | ValuedReactNode;
+export type ConditionalStringValue = string | OptionalString | ValuedString;
+export type ConditionalBooleanValue = boolean | OptionalBoolean | ValuedBoolean;
+export type TooltipType = ConditionalReactNodeValue;
+export type HelpTextType = ConditionalReactNodeValue;
+export type PlaceHolderType = ConditionalStringValue;
+export type HiddenType = ConditionalBooleanValue;
+export type ReadOnlyType = ConditionalBooleanValue;
+export type RequiredType = ConditionalBooleanValue;
+export interface ConditionalValue {
+    entityForm?: EntityForm | undefined;
+    renderType?: RenderType | undefined;
+    value?: FieldValue | undefined;
+    session?: Session | undefined;
+}
+export type ValuedString = (props: ConditionalValue) => Promise<string>;
+export type ValuedBoolean = (props: ConditionalValue) => Promise<boolean>;
+export type ValuedReactNode = (props: ConditionalValue) => Promise<ReactNode>;
+export interface FieldValue<TValue = any> {
+    current?: TValue;
+    fetched?: TValue;
+    default?: TValue;
+}
+export interface OptionalBoolean {
+    onCreate?: boolean;
+    onUpdate?: boolean;
+}
+export interface OptionalReactNode {
+    onCreate?: ReactNode;
+    onUpdate?: ReactNode;
+}
+export interface OptionalString {
+    onCreate?: string;
+    onUpdate?: string;
+}
+export declare function getConditionalBoolean(props: ConditionalValue, condition: ConditionalBooleanValue | undefined): Promise<boolean>;
+export declare function getConditionalString(props: ConditionalValue, condition: ConditionalStringValue | undefined): Promise<string>;
+export declare function getConditionalReactNode(props: ConditionalValue, condition: ConditionalReactNodeValue | undefined): Promise<ReactNode>;
+export type ViewPresetType = 'ALWAYS' | 'ADD_ONLY' | 'MODIFY_ONLY' | 'LIST_ONLY';
+export declare const ViewPresetTypes: SelectOption[];
+export declare function getViewPreset(type: ViewPresetType): ViewPreset;
+export type ViewPreset = {
+    readonly?: OptionalBoolean | ConditionalBooleanValue;
+    hidden?: OptionalBoolean | ConditionalBooleanValue;
+};
+export declare const NO_FILTER_SORT_ON_LIST: IListConfig;
+export declare const ALWAYS: ViewPreset;
+export declare const HIDDEN: ViewPreset;
+export declare const ADD_ONLY: ViewPreset;
+export declare const MODIFY_ONLY: ViewPreset;
+export declare const VIEW_ONLY: ViewPreset;
+export declare const LIST_ONLY: ViewPreset;
+export declare const VIEW_HIDDEN: ViewPreset;
+export type ModifiableType = 'ALWAYS' | 'ADD_ONLY' | 'MODIFY_ONLY' | 'VIEW_ONLY' | 'VIEW_HIDDEN' | 'HIDDEN';
+export declare const ModifiableTypes: SelectOption[];
+export declare function getModifiableType(type: ModifiableType): ViewPreset;
+export declare const HAS_VALUE_READONLY: ViewPreset;
+export declare const HAS_VALUE_HIDDEN: ViewPreset;
+export interface ManyToOneConfig {
+    entityForm: EntityForm;
+    tree?: ManyToOneTreeView;
+    field?: {
+        id?: string;
+        name?: string | ((value: any) => string);
+    };
+    filter?: ManyToOneFilter[];
+    filterable?: boolean;
+    displayFunc?: (value: any) => Promise<string>;
+    fetch?: (value: any) => Promise<any>;
+    modifiable?: boolean | {
+        roles: string[];
+    };
+    hideAdvancedSearch?: boolean;
+}
+export type ManyToOneFilter = (entityForm: EntityForm) => Promise<FilterItem[]>;
+/**
+ * 자기 자신을 ManyToOneField 로 가지고 있는 경우 (location.parentLocation 과 같이)
+ * manyToOne 을 lookup 할 때 자기 자신을 제외하는 필터
+ */
+export declare function excludeSelfOnManyToOneLookup(): ManyToOneFilter;
+export declare function excludeIdListOnManyToOneLookUp(idList?: string[]): ManyToOneFilter;
+export interface ManyToOneTreeView {
+    icon?: ReactNode | ReactNode[];
+    exceptId?: string;
+    rootSelectable?: boolean;
+    leafSelectable?: boolean;
+    fetch?: {
+        url: string;
+        method?: 'GET' | 'POST';
+        convert?: (item: any) => TreeNodeData[];
+        requestBody?: any;
+    };
+    treeData?: TreeNodeData[];
+    onSelectConvert?: (data: TreeNodeData) => any;
+}
+/**
+ * many to one 필드에 대해 필터를 적용할 때, ManyToOne 필드의 fieldValue 를 그대로 searchForm 에 넣으면 안 되는 문제가 있다. 보통 ManyToOne 필드의 FieldValue 는 id 만 있지 않기 때문이다.
+ * 이럴 때 FieldValue 를 꺼내서 parent의 SearchForm에 맞게 변형해 주고, 필터가 해제되면 다시 해당 필드를 제거하는 처리가 필요하다.
+ */
+export interface ParentSearchWith {
+    append?: (name: string, value: any, entityForm?: EntityForm) => Promise<SearchValue>;
+    clear?: string[];
+}
+export interface IAssetConfig {
+    maxSize?: number | undefined;
+    maxCount?: number | undefined;
+    extensions?: string[] | undefined;
+    fileTypes?: string[] | undefined;
+}
+export declare class AssetConfig implements IAssetConfig {
+    maxSize?: number | undefined;
+    maxCount?: number | undefined;
+    extensions?: string[] | undefined;
+    static create(maxSize?: number, maxCount?: number, ...extensions: string[]): AssetConfig;
+    withMaxSize(maxSize?: number): AssetConfig;
+    withMaxCount(maxCount?: number): AssetConfig;
+    withExtensions(...extensions: string[]): this;
+}
+export interface ComboProps {
+    direction?: 'column' | 'row';
+    columns?: number;
+}
+export type MapKey = {
+    key: string;
+    label?: string;
+    required?: boolean;
+};
+export type InlineMapConfig = {
+    keys?: MapKey[];
+    limit?: MinMaxLimit;
+    resultType?: 'KeyValue' | 'Map';
+    label?: {
+        key?: string;
+        value?: string;
+    };
+};
+export type ModifyEntityFormFunc<T extends object = any> = (entityForm: EntityForm<T>, name?: string) => Promise<EntityForm<T>>;
+export type ModifyFetchedEntityFormFunc<T extends object = any> = (entityForm: EntityForm<T>, response?: any) => Promise<EntityForm<T>>;
+export type OnInitializeFunc<T extends object = any> = (entityForm: EntityForm<T>, session?: Session) => Promise<EntityForm<T>>;
+export type TabInfo = {
+    id: string;
+    label: string;
+    order: number;
+    hidden?: boolean | undefined;
+    description?: string | React.ReactNode | undefined;
+    requiredPermissions?: string[] | undefined;
+};
+export type FieldGroupConfig = {
+    open?: boolean;
+};
+export type FieldGroupInfo = {
+    id: string;
+    label: string;
+    order: number;
+    description?: string | undefined;
+    config?: FieldGroupConfig | undefined;
+    requiredPermissions?: string[] | undefined;
+};
+export declare const DEFAULT_TAB_INFO: TabInfo;
+export declare const DEFAULT_FIELD_GROUP_INFO: FieldGroupInfo;
+export declare const STATUS_TAB_INFO: TabInfo;
+export interface InputProps extends AbstractInputProps {
+    value?: any;
+    onChange: (value: any, propagation?: boolean) => void;
+}
+export interface InputRendererProps extends InputProps {
+    onError?: (message: string) => void;
+    clearError?: () => void;
+    regex?: {
+        pattern: RegExp;
+        message: string;
+    };
+}
+export interface AbstractInputProps {
+    name: string;
+    label?: LabelType;
+    errors?: string[];
+    required?: boolean;
+    readonly?: boolean;
+    placeHolder?: string;
+    attributes?: Map<string, unknown>;
+    subCollectionEntity?: boolean;
+}
+export interface EntityFormActionResult {
+    entityForm: EntityForm;
+    actionType?: RenderType;
+    errors?: string[];
+    redirectUrl?: string;
+    refreshOrList?: boolean;
+    messages?: string[];
+    modifiedFields?: string[];
+}
+export type EntityButtonLinkProps = {
+    onClickList?: () => Promise<void>;
+    onSave?: EntityButtonResultProps;
+    onDelete?: EntityButtonResultProps;
+};
+interface EntityButtonResultProps {
+    success?: (result: EntityFormActionResult) => void;
+    failed?: (result: EntityFormActionResult) => void;
+}
+export interface CreateStep {
+    id: string;
+    label: string;
+    order: number;
+    hidden?: boolean;
+    description?: string;
+    fields: string[];
+}
+export interface ManageEntityForm {
+    create: boolean;
+    update: boolean;
+    delete: boolean;
+}
+export declare const MANAGE_ENTITY_ALL: ManageEntityForm;
+export declare const MANAGE_ENTITY_CREATE: ManageEntityForm;
+export declare const MANAGE_ENTITY_UPDATE: ManageEntityForm;
+export declare const MANAGE_ENTITY_NOT_DELETE: ManageEntityForm;
+export declare function onChangeNameToSlug(entityForm: EntityForm, fieldName: string, targetFieldName: string): Promise<EntityForm<any>>;
+export interface CheckButtonValidationFieldProps {
+    url: string;
+    fieldName: string;
+    label: string;
+    parent?: {
+        fieldName: string;
+        value?: string;
+    };
+}
+export declare function checkDuplicateValueProcess({ url, fieldName, label, ...props }: CheckButtonValidationFieldProps): (entityForm: EntityForm, value: any) => Promise<ValidateResult>;
+export {};