@praxisui/core 3.0.0-beta.1 → 3.0.0-beta.3

package/fesm2022/praxisui-core.mjs

@@ -308,6 +308,9 @@ const FieldControlType = {
     INLINE_MULTISELECT: 'inlineMultiSelect',
     INLINE_TOGGLE: 'inlineToggle',
     INLINE_RANGE: 'inlineRange',
+    INLINE_PERIOD_RANGE: 'inlinePeriodRange',
+    INLINE_YEAR_RANGE: 'inlineYearRange',
+    INLINE_MONTH_RANGE: 'inlineMonthRange',
     INLINE_DATE: 'inlineDate',
     INLINE_DATE_RANGE: 'inlineDateRange',
     INLINE_TIME: 'inlineTime',
@@ -394,6 +397,9 @@ const INLINE_FILTER_CONTROL_TYPES = Object.freeze({
     INPUT: FieldControlType.INLINE_INPUT,
     TOGGLE: FieldControlType.INLINE_TOGGLE,
     RANGE: FieldControlType.INLINE_RANGE,
+    PERIOD_RANGE: FieldControlType.INLINE_PERIOD_RANGE,
+    YEAR_RANGE: FieldControlType.INLINE_YEAR_RANGE,
+    MONTH_RANGE: FieldControlType.INLINE_MONTH_RANGE,
     DATE: FieldControlType.INLINE_DATE,
     DATE_RANGE: FieldControlType.INLINE_DATE_RANGE,
     TIME: FieldControlType.INLINE_TIME,
@@ -428,6 +434,9 @@ const INLINE_FILTER_TOKEN_TO_CONTROL_TYPE_MAP = {
     inlineinput: INLINE_FILTER_CONTROL_TYPES.INPUT,
     inlinetoggle: INLINE_FILTER_CONTROL_TYPES.TOGGLE,
     inlinerange: INLINE_FILTER_CONTROL_TYPES.RANGE,
+    inlineperiodrange: INLINE_FILTER_CONTROL_TYPES.PERIOD_RANGE,
+    inlineyearrange: INLINE_FILTER_CONTROL_TYPES.YEAR_RANGE,
+    inlinemonthrange: INLINE_FILTER_CONTROL_TYPES.MONTH_RANGE,
     inlinedate: INLINE_FILTER_CONTROL_TYPES.DATE,
     inlinedaterange: INLINE_FILTER_CONTROL_TYPES.DATE_RANGE,
     inlinetime: INLINE_FILTER_CONTROL_TYPES.TIME,
@@ -456,6 +465,9 @@ const INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE_MAP = {
     inlineinput: FieldControlType.INPUT,
     inlinetoggle: FieldControlType.TOGGLE,
     inlinerange: FieldControlType.RANGE_SLIDER,
+    inlineperiodrange: FieldControlType.RANGE_SLIDER,
+    inlineyearrange: FieldControlType.YEAR_INPUT,
+    inlinemonthrange: FieldControlType.MONTH_INPUT,
     inlinedate: FieldControlType.DATE_PICKER,
     inlinedaterange: FieldControlType.DATE_RANGE,
     inlinetime: FieldControlType.TIME_PICKER,
@@ -635,6 +647,50 @@ class SchemaNormalizerService {
             return { key: String(opt), value: String(opt) };
         });
     }
+    parseOptionSource(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const optionSource = {
+            key: String(value.key ?? '').trim(),
+        };
+        if (!optionSource.key) {
+            return undefined;
+        }
+        if (value.type !== undefined)
+            optionSource.type = String(value.type);
+        if (value.resourcePath !== undefined) {
+            optionSource.resourcePath = String(value.resourcePath);
+        }
+        if (value.filterField !== undefined) {
+            optionSource.filterField = String(value.filterField);
+        }
+        if (value.propertyPath !== undefined) {
+            optionSource.propertyPath = String(value.propertyPath);
+        }
+        if (value.labelPropertyPath !== undefined) {
+            optionSource.labelPropertyPath = String(value.labelPropertyPath);
+        }
+        if (value.valuePropertyPath !== undefined) {
+            optionSource.valuePropertyPath = String(value.valuePropertyPath);
+        }
+        if (value.dependsOn !== undefined) {
+            optionSource.dependsOn = this.parseStringArray(value.dependsOn);
+        }
+        if (value.excludeSelfField !== undefined) {
+            optionSource.excludeSelfField = this.parseBoolean(value.excludeSelfField);
+        }
+        if (value.searchMode !== undefined) {
+            optionSource.searchMode = String(value.searchMode);
+        }
+        if (value.pageSize !== undefined && !Number.isNaN(Number(value.pageSize))) {
+            optionSource.pageSize = Number(value.pageSize);
+        }
+        if (value.includeIds !== undefined) {
+            optionSource.includeIds = this.parseBoolean(value.includeIds);
+        }
+        return optionSource;
+    }
     /**
      * Converte string/Function em função real.
      * Atenção: usa `new Function` para avaliar strings – requer backend confiável.
@@ -1060,12 +1116,21 @@ class SchemaNormalizerService {
             if (ui.endpoint !== undefined) {
                 field.endpoint = ui.endpoint;
             }
+            if (ui.resourcePath !== undefined) {
+                field.resourcePath = ui.resourcePath;
+            }
+            if (ui.optionSource !== undefined) {
+                field.optionSource = this.parseOptionSource(ui.optionSource);
+            }
             if (ui.valueField !== undefined) {
                 field.valueField = ui.valueField;
             }
             if (ui.displayField !== undefined) {
                 field.displayField = ui.displayField;
             }
+            if (ui.filterField !== undefined) {
+                field.filterField = ui.filterField;
+            }
             if (ui.multiple !== undefined) {
                 field.multiple = this.parseBoolean(ui.multiple);
             }
@@ -2743,6 +2808,45 @@ class GenericCrudService {
             return version ? { ...body, dataVersion: version } : body;
         }), catchError(this.handleError));
     }
+    /** OPTION SOURCES: POST /option-sources/{sourceKey}/options/filter */
+    filterOptionSourceOptions(sourceKey, criteria, pageable, opts) {
+        let params = new HttpParams()
+            .set('page', pageable.pageNumber)
+            .set('size', pageable.pageSize);
+        pageable.sort?.forEach((s) => (params = params.append('sort', s)));
+        opts?.includeIds?.forEach((id) => {
+            params = params.append('includeIds', String(id));
+        });
+        if (opts?.search) {
+            params = params.set('search', opts.search);
+        }
+        this.ensureConfigured();
+        const entry = this.resolveEndpointEntry(opts?.endpointKey);
+        const base = `${this.getResourceBaseUrl(opts)}/option-sources/${encodeURIComponent(sourceKey)}/options`;
+        const url = `${base}/filter`;
+        const normalizedCriteria = this.normalizeRangeCriteria(criteria);
+        const observeVersion = !!opts?.observeVersionHeader;
+        const req$ = observeVersion
+            ? this.http.post(url, normalizedCriteria, {
+                params,
+                observe: 'response',
+                headers: composeHeadersWithVersion(entry),
+                context: opts?.httpContext,
+            })
+            : this.http.post(url, normalizedCriteria, {
+                params,
+                headers: composeHeadersWithVersion(entry),
+                context: opts?.httpContext,
+            });
+        if (!observeVersion) {
+            return req$.pipe(catchError(this.handleError));
+        }
+        return req$.pipe(map((resp) => {
+            const body = resp.body;
+            const version = resp.headers.get('X-Data-Version') || undefined;
+            return version ? { ...body, dataVersion: version } : body;
+        }), catchError(this.handleError));
+    }
     /** OPTIONS: GET /options/by-ids */
     getOptionsByIds(ids, options) {
         if (!ids?.length)
@@ -2761,6 +2865,24 @@ class GenericCrudService {
         })
             .pipe(catchError(this.handleError));
     }
+    /** OPTION SOURCES: GET /option-sources/{sourceKey}/options/by-ids */
+    getOptionSourceOptionsByIds(sourceKey, ids, options) {
+        if (!ids?.length)
+            return of([]);
+        let params = new HttpParams();
+        ids.forEach((id) => (params = params.append('ids', String(id))));
+        this.ensureConfigured();
+        const entry = this.resolveEndpointEntry(options?.endpointKey);
+        const base = `${this.getResourceBaseUrl(options)}/option-sources/${encodeURIComponent(sourceKey)}/options`;
+        const url = `${base}/by-ids`;
+        return this.http
+            .get(url, {
+            params,
+            headers: composeHeadersWithVersion(entry),
+            context: options?.httpContext,
+        })
+            .pipe(catchError(this.handleError));
+    }
     /** CURSOR: POST /filter/cursor */
     filterByCursor(criteria, cursorReq = {}, options) {
         let params = new HttpParams();
@@ -10981,6 +11103,19 @@ function normalizeEndpoint(path) {
     // Remove leading slashes and any duplicated `api` segments
     return path.replace(/^\/+/, '').replace(/^(?:api\/)+/, '');
 }
+function normalizeOptionSource(optionSource) {
+    if (!optionSource?.key) {
+        return undefined;
+    }
+    const dependsOn = Array.isArray(optionSource.dependsOn)
+        ? optionSource.dependsOn.filter((value) => typeof value === 'string' && value.trim().length > 0)
+        : undefined;
+    return {
+        ...optionSource,
+        resourcePath: normalizeEndpoint(optionSource.resourcePath),
+        dependsOn: dependsOn?.length ? dependsOn : undefined,
+    };
+}
 /**
  * Converte um FieldDefinition em FieldMetadata.
  *
@@ -11034,6 +11169,7 @@ function mapFieldDefinitionToMetadata(field) {
         'iconClass',
         'iconStyle',
         'iconFontSize',
+        'filterField',
     ];
     for (const prop of simpleProps) {
         const value = field[prop];
@@ -11041,7 +11177,11 @@ function mapFieldDefinitionToMetadata(field) {
             metadata[prop] = value;
         }
     }
-    const endpointPath = normalizeEndpoint(field.resourcePath ?? field.endpoint);
+    const normalizedOptionSource = normalizeOptionSource(field.optionSource);
+    if (normalizedOptionSource) {
+        metadata.optionSource = normalizedOptionSource;
+    }
+    const endpointPath = normalizeEndpoint(normalizedOptionSource?.resourcePath ?? field.resourcePath ?? field.endpoint);
     if (endpointPath) {
         // Canonicalize: only expose resourcePath; do not write legacy alias
         metadata.resourcePath = endpointPath;
@@ -11083,9 +11223,15 @@ function mapFieldDefinitionToMetadata(field) {
     if (field.displayField) {
         metadata.optionLabelKey = field.displayField;
     }
+    else if (normalizedOptionSource) {
+        metadata.optionLabelKey = 'label';
+    }
     if (field.valueField) {
         metadata.optionValueKey = field.valueField;
     }
+    else if (normalizedOptionSource) {
+        metadata.optionValueKey = 'id';
+    }
     if (field.filter) {
         metadata.filterCriteria = field.filter;
     }