@zealicsolutions/web-ui 1.0.140-beta.85 → 1.0.140-beta.87

package/dist/cjs/containers/hooks/index.d.ts

@@ -1,3 +1,8 @@
 export { useCheckCondition } from './useCheckCondition';
+export { useContainerDataScope } from './useContainerDataScope';
+export { useEmptyDataState, isEmptyOrganismData } from './useEmptyDataState';
+export { useEmptyStateFiltering, isEmptyStateContainer, getEmptyStateReplicatorFieldId, isArrayFieldEmptyAtScope, } from './useEmptyStateFiltering';
+export { useEmptyStateVisibility, isArrayFieldEmpty } from './useEmptyStateVisibility';
 export { useFormOrganismItem } from './useFormOrganismItem';
 export { useStateModifierHandler } from './useStateModifierHandler';
+export { useVisibleItems } from './useVisibleItems';

package/dist/cjs/containers/hooks/useContainerDataScope.d.ts

@@ -0,0 +1,20 @@
+import { PathSegment } from '../../contexts/ContainerRuntimeContext/types';
+export type UseContainerDataScopeParams = {
+    /**
+     * Current nested path segments from the container hierarchy
+     */
+    nestedPathSegments: PathSegment[];
+};
+/**
+ * Hook that resolves the current data scope for a container.
+ *
+ * The data scope is determined by:
+ * 1. If inside a replicator (parentContext has itemDataByDmfId) - use parent's item data
+ * 2. Otherwise - navigate from data root using nestedPathSegments
+ *
+ * This is used to check if array fields are empty at the current nesting level.
+ *
+ * @param params - Parameters containing path segments
+ * @returns Current data scope as a record, or undefined if no data
+ */
+export declare const useContainerDataScope: ({ nestedPathSegments, }: UseContainerDataScopeParams) => Record<string, unknown> | undefined;

package/dist/cjs/containers/hooks/useEmptyDataState.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Response shape from organism data API.
+ * Empty data is identified when viewType is null and data is empty object.
+ */
+export type OrganismDataResponse = {
+    viewType: string | null;
+    data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+};
+/**
+ * Hook to detect if organism data represents an empty state.
+ *
+ * Empty data is identified when:
+ * - viewType is null AND
+ * - data object is empty or undefined
+ *
+ * @param organismData - The data response from the backend
+ * @returns boolean indicating if the data represents an empty state
+ *
+ * @example
+ * ```typescript
+ * // Empty data response from backend
+ * const emptyResponse = { viewType: null, data: {}, metadata: {} };
+ * const isEmpty = useEmptyDataState(emptyResponse); // true
+ *
+ * // Non-empty data response
+ * const dataResponse = { viewType: 'data_grid', data: { rows: [...] }, metadata: {} };
+ * const isEmpty = useEmptyDataState(dataResponse); // false
+ * ```
+ */
+export declare const useEmptyDataState: (organismData: unknown) => boolean;
+/**
+ * Helper function to check if data is empty (non-hook version).
+ * Useful for one-off checks outside of React components.
+ */
+export declare const isEmptyOrganismData: (organismData: unknown) => boolean;

package/dist/cjs/containers/hooks/useEmptyStateFiltering.d.ts

@@ -0,0 +1,62 @@
+import { DmfId, PathSegment } from '../../contexts/ContainerRuntimeContext/types';
+import { ContainerComponentProps, Molecule } from '../types/types';
+/**
+ * Checks if an item is an empty_state container.
+ */
+export declare const isEmptyStateContainer: (item: ContainerComponentProps | Molecule) => boolean;
+/**
+ * Gets the replicatorFieldId from an empty_state container.
+ */
+export declare const getEmptyStateReplicatorFieldId: (item: ContainerComponentProps | Molecule) => DmfId | undefined;
+/**
+ * Checks if a specific array field is empty at the given scope.
+ */
+export declare const isArrayFieldEmptyAtScope: (scope: Record<string, unknown> | undefined, replicatorFieldId: DmfId) => boolean;
+export type UseEmptyStateFilteringParams = {
+    /**
+     * All container items (before visibility filtering)
+     */
+    containerItems: (ContainerComponentProps | Molecule)[] | undefined;
+    /**
+     * Items already filtered by visibility
+     */
+    visibleItems: (ContainerComponentProps | Molecule)[];
+    /**
+     * Current nested path segments for data scope resolution
+     */
+    nestedPathSegments: PathSegment[];
+};
+export type EmptyStateFilterResult = {
+    /**
+     * Items filtered based on empty state logic
+     */
+    filteredItems: (ContainerComponentProps | Molecule)[];
+    /**
+     * Set of replicatorFieldIds that have their empty state currently showing
+     */
+    showingEmptyStateForFields: Set<string>;
+    /**
+     * Whether organism-level empty state is showing
+     */
+    showOrganismLevelEmptyState: boolean;
+};
+/**
+ * Hook that filters container items based on empty state logic.
+ *
+ * **Design Mode (isConfigurationMode=true):**
+ * - All containers including empty_state are visible for editing
+ * - Preview mode via popover can simulate empty data state
+ *
+ * **Runtime Mode (isConfigurationMode=false):**
+ * - empty_state containers shown based on actual data emptiness
+ * - With replicatorFieldId: shows when that array is empty
+ * - Without replicatorFieldId: shows when organism data is empty
+ *
+ * When an empty_state is shown (runtime or preview):
+ * - If it has replicatorFieldId: hides sibling replicator with same fieldId
+ * - If no replicatorFieldId: hides all containers after it
+ *
+ * @param params - Parameters for filtering
+ * @returns Filtered items and empty state visibility info
+ */
+export declare const useEmptyStateFiltering: ({ containerItems, visibleItems, nestedPathSegments, }: UseEmptyStateFilteringParams) => EmptyStateFilterResult;

package/dist/cjs/containers/hooks/useEmptyStateVisibility.d.ts

@@ -0,0 +1,37 @@
+import { DmfId, PathSegment } from '../../contexts/ContainerRuntimeContext/types';
+export type EmptyStateConfig = {
+    /**
+     * The replicatorFieldId this empty state is associated with.
+     * If undefined, applies to entire organism data.
+     */
+    replicatorFieldId?: DmfId;
+    /**
+     * Current nested path segments from the container context.
+     */
+    nestedPathSegments?: PathSegment[];
+};
+/**
+ * Hook to determine if an empty_state container should be visible.
+ *
+ * Logic:
+ * - If replicatorFieldId is NOT set → check if entire organism data is empty
+ * - If replicatorFieldId IS set → check if that specific array field is empty at current path
+ *
+ * @param config - Configuration with replicatorFieldId and nestedPathSegments
+ * @returns Object with visibility info and preview state management
+ */
+export declare const useEmptyStateVisibility: (config: EmptyStateConfig) => {
+    shouldShow: boolean;
+    reason: "preview";
+} | {
+    shouldShow: boolean | undefined;
+    reason: "organism_empty" | "has_data";
+} | {
+    shouldShow: boolean;
+    reason: "array_empty" | "has_items";
+};
+/**
+ * Check if a specific array field is empty at the given path.
+ * Non-hook version for use outside React components.
+ */
+export declare const isArrayFieldEmpty: (dataRoot: Record<string, unknown>, nestedPathSegments: PathSegment[], replicatorFieldId: DmfId) => boolean;

package/dist/cjs/containers/hooks/useVisibleItems.d.ts

@@ -0,0 +1,18 @@
+import { ContainerComponentProps, Molecule } from '../types/types';
+export type UseVisibleItemsParams = {
+    /**
+     * Array of container items or molecules to filter
+     */
+    items: (ContainerComponentProps | Molecule)[] | undefined;
+};
+/**
+ * Hook that filters container items based on visibility state.
+ *
+ * Checks both:
+ * - `config.props.visible` - static visibility from configuration
+ * - `stateObject[id].visible` - dynamic visibility from state
+ *
+ * @param params - Parameters containing items to filter
+ * @returns Filtered array of visible items
+ */
+export declare const useVisibleItems: ({ items }: UseVisibleItemsParams) => any[];

package/dist/cjs/containers/types/types.d.ts

@@ -4,7 +4,7 @@ import { ValidationMode } from 'react-hook-form';
 import { SizesTypes } from 'theme';
 import type { AnyObject, Nullable, StylesType } from '../../typescript';
 import { Molecule } from './moleculeTypes';
-export type ContainerType = 'default' | 'row' | 'column' | 'slider' | 'form' | 'form_purpose' | 'form_step' | 'dynamic' | 'journey_driven' | 'journey_driven_step' | 'replicator';
+export type ContainerType = 'default' | 'row' | 'column' | 'slider' | 'form' | 'form_purpose' | 'form_step' | 'dynamic' | 'journey_driven' | 'journey_driven_step' | 'replicator' | 'empty_state';
 export type ContainerTemplateType = 'row_content_container';
 export type WrappedContainerType = Extract<ContainerType, 'form' | 'form_step' | 'replicator'>;
 export type DmfId = string;

package/dist/cjs/contexts/OrganismContext/OrganismContext.d.ts

@@ -61,5 +61,28 @@ export type OrganismContextType = {
     loadRecordData?: (args: {
         rwoRecordId: string;
     }) => Promise<Record<string, unknown>>;
+    /**
+     * Indicates whether the organism has empty data from the backend.
+     * Used by containers to determine if empty_state container should be shown.
+     * When true, containers after empty_state are not rendered.
+     */
+    isEmptyDataState?: boolean;
+    /**
+     * Forces empty state display for design preview purposes.
+     * When true, empty_state containers are shown regardless of actual data.
+     * Used by the designer to preview how the organism looks with no data.
+     */
+    forceEmptyStatePreview?: boolean;
+    /**
+     * Array of replicatorFieldIds for which empty states are being previewed.
+     * Use '__organism__' for the organism-level empty state (no replicatorFieldId).
+     * This allows granular control over which nested empty states to show in designer.
+     */
+    previewingEmptyStates?: string[];
+    /**
+     * Callback to toggle preview of a specific empty state in designer.
+     * @param replicatorFieldId - The field ID to toggle, or '__organism__' for organism-level
+     */
+    toggleEmptyStatePreview?: (replicatorFieldId: string) => void;
 };
 export declare const OrganismContext: React.Context<OrganismContextType>;

package/dist/cjs/contexts/OrganismContext/OrganismContextProvider.d.ts

@@ -55,5 +55,13 @@ export type OrganismContextProviderProps = React.PropsWithChildren<{} & Partial<
     loadRecordData: (args: {
         rwoRecordId: string;
     }) => Promise<Record<string, unknown>>;
+    /** Indicates organism has empty data from backend */
+    isEmptyDataState: boolean;
+    /** Forces empty state preview for designer mode */
+    forceEmptyStatePreview: boolean;
+    /** Array of replicatorFieldIds being previewed */
+    previewingEmptyStates: string[];
+    /** Callback to toggle empty state preview */
+    toggleEmptyStatePreview: (replicatorFieldId: string) => void;
 }>>;
-export declare const OrganismContextProvider: ({ initItems, children, submitHandler, formId, validations, editable, isPreview, organismBodyId, isFormInEditMode, organismMetadata, organismInfo, localStateObject, isConfigurationMode, onConfigurationItemHandler, selectedConfigurationItemId, currentStyleProperties, currentContentProperties, onInternalNavigation, routing, prefillData, loadRecordData, }: OrganismContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const OrganismContextProvider: ({ initItems, children, submitHandler, formId, validations, editable, isPreview, organismBodyId, isFormInEditMode, organismMetadata, organismInfo, localStateObject, isConfigurationMode, onConfigurationItemHandler, selectedConfigurationItemId, currentStyleProperties, currentContentProperties, onInternalNavigation, routing, prefillData, loadRecordData, isEmptyDataState, forceEmptyStatePreview, previewingEmptyStates, toggleEmptyStatePreview, }: OrganismContextProviderProps) => import("@emotion/react/jsx-runtime").JSX.Element;