forlogic-core 1.20.0 → 2.0.0

package/dist/components/dashboards/dashboard-view.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import { type Dashboard, type DashboardPage, type DashboardPanel } from './types';
+import { type GridPanelLayout } from './dashboard-grid';
+import { type DashboardPanelRendererProps } from './dashboard-panel-renderer';
+export interface DashboardViewProps {
+    /** Dashboard metadata */
+    dashboard: Dashboard;
+    /** Panels to render */
+    panels: DashboardPanel[];
+    /** Pages (for carousel mode) */
+    pages?: DashboardPage[];
+    /** Current active page ID (carousel mode) */
+    activePageId?: string;
+    /** Allow editing (drag, resize, add, remove) */
+    canEdit?: boolean;
+    /** Fullscreen mode */
+    isFullscreen?: boolean;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Per-panel data provider: return panel-specific data for rendering */
+    getPanelData?: (panelId: string) => Omit<DashboardPanelRendererProps, 'config'>;
+    /** Callbacks */
+    onRefresh?: () => void;
+    onToggleFullscreen?: () => void;
+    onToggleFavorite?: () => void;
+    onEdit?: () => void;
+    onShare?: () => void;
+    onAddPanel?: () => void;
+    onEditPanel?: (panelId: string) => void;
+    onRemovePanel?: (panelId: string) => void;
+    onDuplicatePanel?: (panelId: string) => void;
+    onLayoutChange?: (panels: GridPanelLayout[]) => void;
+    onPageChange?: (pageId: string) => void;
+    /** Custom toolbar actions */
+    toolbarActions?: ReactNode;
+    className?: string;
+}
+export declare function DashboardView({ dashboard, panels, pages, activePageId, canEdit, isFullscreen, isLoading, getPanelData, onRefresh, onToggleFullscreen, onToggleFavorite, onEdit, onShare, onAddPanel, onEditPanel, onRemovePanel, onDuplicatePanel, onLayoutChange, onPageChange, toolbarActions, className, }: DashboardViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/helpers.d.ts

@@ -0,0 +1,47 @@
+import type { PanelResult, PlaceAnalysis } from './types';
+/** Month abbreviation → number (pt-BR) */
+export declare const MONTHS_MAP: Record<string, number>;
+/** localStorage keys used by dashboard module */
+export declare const DASHBOARD_STORAGE_KEYS: {
+    readonly advancedFilter: "analysisDashboardsListFilter";
+};
+/** Fields known to contain currency values */
+export declare const CURRENCY_FIELDS: readonly ["total_calibration_cost", "total_verification_cost", "total_maintenance_cost", "last_calibration_cost", "last_verification_cost", "last_maintenance_cost", "total_cost", "total_reported_cost", "estimated_cost", "last_report_cost_reported_cost", "occurrence_reported_cost", "task_estimated_cost"];
+/** Properties that may contain a navigable link in a row */
+export declare const LINK_PROPERTIES: readonly ["link", "link_risk", "risk_link", "link_group", "group_link", "link_occurrence", "occurrence_link", "link_audit", "link_project", "link_program", "link_ideia", "flow_link", "decision_link", "link_supplier", "auditing_link", "fmea_link"];
+/**
+ * Sort panel results by month/year date (pt-BR format: "jan/2024").
+ */
+export declare function sortByMonthYear(dataSource: PanelResult[]): PanelResult[];
+/**
+ * Check if a field value is null, undefined, or an empty string.
+ */
+export declare function isNullOrEmptyField(field: {
+    value?: string | null;
+} | null | undefined): boolean;
+/**
+ * Sanitize the last segment of a URL (title) by removing special chars and encoding.
+ */
+export declare function processUrl(url: string): string;
+/**
+ * Get the first navigable link found in a row object.
+ */
+export declare function getLinkFromRow(row: Record<string, unknown>): string | null;
+/**
+ * Serialize an object to query-string format (key=value&key=value).
+ */
+export declare function toQueryString(obj: Record<string, unknown> | null | undefined): string | null;
+/**
+ * Check if a string looks like a currency value.
+ */
+export declare function isCurrency(value: string): boolean;
+/**
+ * Extract a numeric value from a formatted currency string (pt-BR format).
+ */
+export declare function extractNumberFromCurrency(value: string): number;
+/** Pre-built pt-BR currency formatter */
+export declare const currencyFormatter: Intl.NumberFormat;
+/**
+ * Build a hierarchical tree from a flat list of places.
+ */
+export declare function buildPlacesTree(places: PlaceAnalysis[]): PlaceAnalysis[];

package/dist/components/dashboards/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './helpers';
+export * from './panels';
+export { DashboardGrid, getDefaultPanelSize, getMinPanelSize, type GridPanelLayout, type DashboardGridProps } from './dashboard-grid';
+export { DashboardPanelRenderer, type DashboardPanelRendererProps } from './dashboard-panel-renderer';
+export { DashboardView, type DashboardViewProps } from './dashboard-view';
+export { DashboardList, type DashboardListProps } from './dashboard-list';
+export { DashboardForm, type DashboardFormProps, type DashboardFormValues } from './dashboard-form';
+export { DashboardGeneralView, type DashboardGeneralViewProps, type DashboardViewState } from './dashboard-general-view';

package/dist/components/dashboards/panels/burndown-panel.d.ts

@@ -0,0 +1,26 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+export interface BurndownDataPoint {
+    date: string;
+    executedPercentage: number;
+    plannedPercentage: number;
+    tooltipExecuted?: string;
+    tooltipPlanned?: string;
+}
+export interface BurndownPanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    data?: BurndownDataPoint[];
+    /** Labels for series */
+    executedLabel?: string;
+    plannedLabel?: string;
+    /** Colors */
+    executedColor?: string;
+    plannedColor?: string;
+    viewOnly?: boolean;
+    onRefresh?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function BurndownPanel({ config, state, data, executedLabel, plannedLabel, executedColor, plannedColor, viewOnly, onRefresh, queryUrl, queryUrlBuilder, className, }: BurndownPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/cartesian-panel.d.ts

@@ -0,0 +1,46 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+export type CartesianVariant = 'bar' | 'column' | 'stacked-column' | 'area' | 'line' | 'evolution-line';
+export interface CartesianSeries {
+    /** Data key in each data point */
+    dataKey: string;
+    /** Display name in legend/tooltip */
+    name?: string;
+    /** Color override */
+    color?: string;
+    /** Stack ID for stacked charts */
+    stackId?: string;
+}
+export interface CartesianPanelProps {
+    config: PanelConfig;
+    /** Chart variant to render */
+    variant: CartesianVariant;
+    /** Current state of the panel */
+    state: PanelState;
+    /**
+     * Transformed chart data — array of objects where each object is a data point.
+     * Must include a `name` or `key` field for the category axis.
+     */
+    data?: Record<string, unknown>[];
+    /**
+     * Series definitions. If omitted, a single series using `value` dataKey is assumed.
+     */
+    series?: CartesianSeries[];
+    /** Palette hex colors to use for series (from config or custom) */
+    colors?: string[];
+    /** Category axis data key (default: 'key') */
+    categoryKey?: string;
+    /** Y-axis label format (e.g. 'R$ {value}') */
+    yAxisFormat?: string;
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    /** Called when a data point is clicked */
+    onPointClick?: (data: Record<string, unknown>, index: number) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function CartesianPanel({ config, variant, state, data, series: seriesProp, colors: colorsProp, categoryKey, yAxisFormat, viewOnly, onPointClick, onRefresh, onExport, queryUrl, queryUrlBuilder, className, }: CartesianPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/index.d.ts

@@ -0,0 +1,14 @@
+export { PanelHeader, type PanelHeaderProps } from './panel-header';
+export { PanelError, type PanelErrorProps } from './panel-error';
+export { PanelLoader, type PanelLoaderProps } from './panel-loader';
+export { PanelNoData, type PanelNoDataProps } from './panel-no-data';
+export { PanelUnavailable, type PanelUnavailableProps } from './panel-unavailable';
+export { NumericPanel, type NumericPanelProps } from './numeric-panel';
+export { TextPanel, type TextPanelProps } from './text-panel';
+export { ListPanel, type ListPanelProps, type ListPanelColumn } from './list-panel';
+export { CartesianPanel, type CartesianPanelProps, type CartesianVariant, type CartesianSeries } from './cartesian-panel';
+export { PiePanel, type PiePanelProps } from './pie-panel';
+export { ParetoPanel, type ParetoPanelProps } from './pareto-panel';
+export { BurndownPanel, type BurndownPanelProps, type BurndownDataPoint } from './burndown-panel';
+export { PerformancePanel, type PerformancePanelProps, type PerformanceDataPoint } from './performance-panel';
+export { MatrixRiskPanel, type MatrixRiskPanelProps, type MatrixRule, type MatrixParameter, type MatrixRisk } from './matrix-risk-panel';

package/dist/components/dashboards/panels/list-panel.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig, type SelectedColumn } from '../types';
+export interface ListPanelColumn extends SelectedColumn {
+    /** Render function override for custom cell content */
+    render?: (value: unknown, row: Record<string, unknown>) => React.ReactNode;
+}
+export interface ListPanelProps {
+    config: PanelConfig;
+    /** Current state of the panel */
+    state: PanelState;
+    /** Row data */
+    data?: Record<string, unknown>[];
+    /** Column definitions */
+    columns?: ListPanelColumn[];
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    /** Called when a row is clicked */
+    onRowClick?: (row: Record<string, unknown>) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    /** Query URL builder for header */
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    /** Whether to auto-navigate to row links on click */
+    enableRowLinks?: boolean;
+    className?: string;
+}
+export declare function ListPanel({ config, state, data, columns, viewOnly, onRowClick, onRefresh, onExport, queryUrl, queryUrlBuilder, enableRowLinks, className, }: ListPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/matrix-risk-panel.d.ts

@@ -0,0 +1,49 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, MatrixViewType, type PanelConfig } from '../types';
+export interface MatrixParameter {
+    name: string;
+    position: number;
+}
+export interface MatrixRule {
+    name_x: string;
+    name_y: string;
+    parametersX: MatrixParameter[];
+    parametersY: MatrixParameter[];
+    threat_strategy_type_name?: string;
+    opportunity_strategy_type_name?: string;
+    disable_opportunities?: boolean;
+    /** Matrix of colors indexed [y][x] */
+    colorMatrix?: string[][];
+}
+export interface MatrixRisk {
+    code: string;
+    name: string;
+    parameterXPosition: number;
+    parameterYPosition: number;
+    analysisDate?: string;
+    parameterXName?: string;
+    parameterValueX?: string;
+    parameterYName?: string;
+    parameterValueY?: string;
+    strategy?: string;
+    resultName?: string;
+    link?: string;
+}
+export interface MatrixRiskPanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    /** The analysis rule defining axes and colors */
+    rule?: MatrixRule;
+    /** List of risks to plot on the matrix */
+    risks?: MatrixRisk[];
+    /** View mode: quantity count or individual risk codes */
+    matrixViewType?: MatrixViewType;
+    viewOnly?: boolean;
+    onCellClick?: (x: MatrixParameter, y: MatrixParameter, risks: MatrixRisk[]) => void;
+    onRiskClick?: (risk: MatrixRisk) => void;
+    onRefresh?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function MatrixRiskPanel({ config, state, rule, risks, matrixViewType, viewOnly, onCellClick, onRiskClick, onRefresh, queryUrl, queryUrlBuilder, className, }: MatrixRiskPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/numeric-panel.d.ts

@@ -0,0 +1,22 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+export interface NumericPanelProps {
+    config: PanelConfig;
+    /** Current state of the panel */
+    state: PanelState;
+    /** The numeric value to display */
+    value?: number | string | null;
+    /** Optional: override the aggregation label */
+    label?: string;
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    /** Called when clicking the numeric value (e.g. to open popover) */
+    onClick?: () => void;
+    onRefresh?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    /** Query URL builder for header */
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function NumericPanel({ config, state, value, label, viewOnly, onClick, onRefresh, queryUrl, queryUrlBuilder, className, }: NumericPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/panel-error.d.ts

@@ -0,0 +1,8 @@
+import type { PanelConfig } from '../types';
+export interface PanelErrorProps {
+    config: PanelConfig;
+    /** URL to the query for troubleshooting */
+    queryUrl?: string;
+    className?: string;
+}
+export declare function PanelError({ config, queryUrl, className }: PanelErrorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/panel-header.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import { type PanelConfig } from '../types';
+export interface PanelHeaderProps {
+    config: PanelConfig;
+    /** Hide the options menu (e.g. in general-view mode) */
+    viewOnly?: boolean;
+    /** Extra content to render in a specific slot */
+    complement?: ReactNode;
+    complementPosition?: 'before-title' | 'after-title' | 'before-options' | 'after-options';
+    /** URL builder for the "Open query" link */
+    queryUrlBuilder?: (config: PanelConfig) => string;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    onToggleOnlyMine?: (value: boolean) => void;
+    className?: string;
+}
+export declare function PanelHeader({ config, viewOnly, complement, complementPosition, queryUrlBuilder, onRefresh, onExport, onToggleOnlyMine, className, }: PanelHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/panel-loader.d.ts

@@ -0,0 +1,7 @@
+import { DashboardPanelType } from '../types';
+export interface PanelLoaderProps {
+    /** Show extra "please wait" message for long-running panel types */
+    panelType?: DashboardPanelType;
+    className?: string;
+}
+export declare function PanelLoader({ panelType, className }: PanelLoaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/panel-no-data.d.ts

@@ -0,0 +1,6 @@
+export interface PanelNoDataProps {
+    /** Whether the panel has a removed column (shows different message) */
+    hasRemovedColumn?: boolean;
+    className?: string;
+}
+export declare function PanelNoData({ hasRemovedColumn, className }: PanelNoDataProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/panel-unavailable.d.ts

@@ -0,0 +1,6 @@
+export interface PanelUnavailableProps {
+    /** Callback to remove the panel */
+    onRemove?: () => void;
+    className?: string;
+}
+export declare function PanelUnavailable({ onRemove, className }: PanelUnavailableProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/pareto-panel.d.ts

@@ -0,0 +1,20 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig, type PanelResult } from '../types';
+export interface ParetoPanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    /** Bar data — each item needs `key` (label) and `value` (count) */
+    data?: PanelResult[];
+    /** Override bar color */
+    barColor?: string;
+    /** Override line color */
+    lineColor?: string;
+    viewOnly?: boolean;
+    onPointClick?: (entry: PanelResult, index: number) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function ParetoPanel({ config, state, data, barColor, lineColor, viewOnly, onPointClick, onRefresh, onExport, queryUrl, queryUrlBuilder, className, }: ParetoPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/performance-panel.d.ts

@@ -0,0 +1,24 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+export interface PerformanceDataPoint {
+    name: string;
+    executedWork: number;
+    plannedWork: number;
+    [key: string]: unknown;
+}
+export interface PerformancePanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    data?: PerformanceDataPoint[];
+    executedLabel?: string;
+    plannedLabel?: string;
+    executedColor?: string;
+    plannedColor?: string;
+    viewOnly?: boolean;
+    onPointClick?: (entry: PerformanceDataPoint, index: number) => void;
+    onRefresh?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function PerformancePanel({ config, state, data, executedLabel, plannedLabel, executedColor, plannedColor, viewOnly, onPointClick, onRefresh, queryUrl, queryUrlBuilder, className, }: PerformancePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/pie-panel.d.ts

@@ -0,0 +1,19 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig, type PanelResult } from '../types';
+export interface PiePanelProps {
+    config: PanelConfig;
+    state: PanelState;
+    /** Chart data — each item needs `key` (label) and `value` (number) */
+    data?: PanelResult[];
+    /** Override palette colors */
+    colors?: string[];
+    viewOnly?: boolean;
+    /** Called when a slice is clicked */
+    onSliceClick?: (entry: PanelResult, index: number) => void;
+    onRefresh?: () => void;
+    onExport?: () => void;
+    queryUrl?: string;
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function PiePanel({ config, state, data, colors: colorsProp, viewOnly, onSliceClick, onRefresh, onExport, queryUrl, queryUrlBuilder, className, }: PiePanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dashboards/panels/text-panel.d.ts

@@ -0,0 +1,18 @@
+import { type PanelHeaderProps } from './panel-header';
+import { PanelState, type PanelConfig } from '../types';
+export interface TextPanelProps {
+    config: PanelConfig;
+    /** Current state of the panel */
+    state: PanelState;
+    /** HTML content to render (from textTypeString) */
+    htmlContent?: string;
+    /** View-only mode (hides header menu) */
+    viewOnly?: boolean;
+    onRefresh?: () => void;
+    /** URL to the query for error state */
+    queryUrl?: string;
+    /** Query URL builder for header */
+    queryUrlBuilder?: PanelHeaderProps['queryUrlBuilder'];
+    className?: string;
+}
+export declare function TextPanel({ config, state, htmlContent, viewOnly, onRefresh, queryUrl, queryUrlBuilder, className, }: TextPanelProps): import("react/jsx-runtime").JSX.Element;