@genispace/geniapp 0.2.0 → 0.4.0

package/dist/components/internal/workbench/utils/grid24LayoutSystem.d.ts

@@ -0,0 +1,108 @@
+import { Grid24Preset, Grid24Component, Grid24LayoutConfig } from '../types/components';
+
+export declare const MAX_GRID24_NESTING_DEPTH = 3;
+export interface Grid24PresetConfig {
+    rows: Array<{
+        colSpan: number;
+    }>;
+}
+/** Preset id → i18n key under `workbench:grid24.presets.*` (underscores). */
+export declare function grid24PresetToTranslationKey(preset: Exclude<Grid24Preset, 'custom'>): string;
+/** English labels for `t(..., defaultValue)` before workbench namespace loads. */
+export declare const GRID24_PRESET_LABEL_FALLBACK: Record<Exclude<Grid24Preset, 'custom'>, string>;
+export declare const GRID24_PRESETS: Record<Exclude<Grid24Preset, 'custom'>, Grid24PresetConfig>;
+export declare function generateComponentsFromPreset(preset: Exclude<Grid24Preset, 'custom'>, componentIds: string[]): Grid24Component[];
+export declare function computeRowCount(components: Grid24Component[]): number;
+export declare function groupComponentsByRow(components: Grid24Component[]): Grid24Component[][];
+export declare function validateRowColSpan(components: Grid24Component[]): boolean;
+export declare function detectOverlaps(components: Grid24Component[]): Grid24Component[][];
+export declare function getComponentGridRow(comp: Grid24Component): string;
+export declare function getComponentGridColumn(comp: Grid24Component): string;
+/** Fill spacing / row metrics when absent (e.g. legacy API omitting fields). */
+export declare function applyGrid24LayoutDefaults(config: Partial<Grid24LayoutConfig> & {
+    type: 'grid-24';
+    components?: Grid24Component[];
+}): Grid24LayoutConfig;
+export declare function createDefaultGrid24Layout(componentIds: string[]): Grid24LayoutConfig;
+/**
+ * Sizing capability model (see docs: workbench-component-sizing-plan.md).
+ *
+ * Height semantics per component type:
+ * - 'content'      height follows content; vertical resize is DISABLED in the
+ *                  canvas and the view renders its rows as auto-height.
+ * - 'fill'         the component stretches/scrolls to the assigned rowSpan;
+ *                  the view renders the cell at the exact band height.
+ * Every type has one explicit height owner. New/unknown components fail safe
+ * to content mode, so the editor never offers a vertical resize that the
+ * published renderer cannot honor.
+ *
+ * w/h are the DEFAULT spans (kept identical to the pre-model values — zero
+ * migration); min/max are enforced by canvas handles, keyboard nudge and the
+ * copilot layout tools.
+ */
+export type Grid24SizeMode = 'content' | 'fill';
+export interface Grid24SizeCapability {
+    w: number;
+    h: number;
+    mode: Grid24SizeMode;
+    minW: number;
+    maxW: number;
+    minH?: number;
+    maxH?: number;
+    widthResizable: boolean;
+    heightResizable: boolean;
+}
+export declare const GRID24_SIZE_CAPABILITIES: Record<string, Grid24SizeCapability>;
+export declare function getGrid24SizeCapability(type?: string): Grid24SizeCapability;
+/** Backward-compatible projections (palette drops, merge synthesis, copilot). */
+export declare const GRID24_DEFAULT_SIZES: Record<string, {
+    w: number;
+    h: number;
+}>;
+export declare function getGrid24DefaultSize(type?: string): {
+    w: number;
+    h: number;
+};
+/** Clamp a span patch to the type's capability (copilot layout tools, nudge).
+    content-mode heights are NOT adjustable: rowSpan writes are dropped (the
+    view sizes those rows to content and auto-fit maintains the nominal span). */
+export declare function clampGrid24SpanToCapability(type: string | undefined, span: {
+    colSpan?: number;
+    rowSpan?: number;
+}): {
+    colSpan?: number;
+    rowSpan?: number;
+};
+type Grid24Child = string | {
+    id: string;
+    type?: string;
+};
+/**
+ * Vertical gravity compaction in grid space (classic dashboard behavior —
+ * Retool/Appsmith/Gridstack default): every item floats UP until it touches
+ * another item or the top. Freed space (shrink/move-away) is reclaimed
+ * automatically instead of requiring manual pull-ups. Intentional vertical
+ * whitespace is expressed via component padding / future Spacer components,
+ * not empty rows.
+ */
+export declare function compactGrid24Vertical(components: Grid24Component[]): Grid24Component[];
+/**
+ * Push-down overlap resolution in grid space (mirror of the canvas compactor):
+ * identity when nothing overlaps; otherwise the activeId item keeps its cell
+ * (insert semantics — dropping between two components pushes the ones below
+ * DOWN, it never relocates the dropped item to the bottom) and later items in
+ * reading order yield downward.
+ */
+export declare function resolveGrid24Push(components: Grid24Component[], activeId?: string): Grid24Component[];
+/** Ensure every child id has a grid entry; append missing in new rows (full
+    width, type-default height when the child's type is provided). */
+export declare function mergeGrid24WithChildIds(config: Grid24LayoutConfig, children: Grid24Child[]): Grid24LayoutConfig;
+export declare function sortChildComponentsByGrid<T extends {
+    id: string;
+}>(children: T[] | undefined, grid: Grid24Component[]): T[];
+export declare function normalizeGrid24Components(components: Grid24Component[]): Grid24Component[];
+/**
+ * Label shown on 24-grid editor tiles: localized type + " · " + title (or untitled).
+ */
+export declare function getGrid24ComponentSlotLabel(component: any): string;
+export {};

package/dist/components/internal/workbench/utils/iconUtils.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+
+export declare const ICON_MAPPINGS: {
+    [key: string]: React.ComponentType<{
+        className?: string;
+    }>;
+};
+export declare const getLucideIcons: () => {
+    value: string;
+    label: string;
+}[];
+export declare const LUCIDE_ICONS: {
+    value: string;
+    label: string;
+}[];
+export declare const renderLucideIcon: (iconName: string, className?: string) => React.ReactNode;
+export declare const getIconComponent: (icon: string, size?: number, className?: string) => React.ReactNode;
+export declare const hasIcon: (iconName: string) => boolean;
+export declare const getAvailableIcons: () => {
+    value: string;
+    label: string;
+}[];

package/dist/components/internal/workbench/utils/layoutContainerNesting.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Nesting depth of a layout container (Container | Card | Tabs) from the page root.
+ * Page is not counted. Top-level container depth = 0 (matches PageComponentRenderer default nestingLevel).
+ */
+export declare function getLayoutContainerNestingLevel(components: unknown[] | undefined, targetId: string, ancestorDepth?: number): number | null;

package/dist/components/internal/workbench/utils/layoutSystem.d.ts

@@ -0,0 +1,189 @@
+export type LayoutPreset = 'all-vertical' | 'top1-bottom2' | 'top1-bottom2-equal' | 'left1-right2' | 'top1-bottom3' | 'top1-bottom2-left-large' | 'dashboard-layout' | 'left3-right1';
+export type GridArea = 'top' | 'bottom' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'bottom-second' | 'left' | 'left-top' | 'left-center' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom' | 'header' | 'middle-left' | 'middle-center' | 'middle-right' | 'middle';
+export interface LayoutConfig {
+    type: 'default' | 'custom';
+    preset: LayoutPreset;
+    componentPositions?: Record<string, {
+        area: GridArea;
+        order: number;
+        span?: number;
+    }>;
+}
+export interface ComponentItem {
+    id: string;
+    type: string;
+    title?: string;
+    area: GridArea;
+    order: number;
+}
+export declare const getLayoutPresets: () => {
+    readonly 'all-vertical': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr";
+            readonly rows: "auto";
+            readonly areas: "\"top\"";
+        };
+    };
+    readonly 'top1-bottom3': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top top\"\n        \"bottom-left bottom-center bottom-right\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top top\"\n        \"bottom-left bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2-equal': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top\"\n        \"bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'left1-right2': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"left right-top right-top\"\n        \"left right-bottom right-bottom\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2-left-large': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 2fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top\"\n        \"bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'dashboard-layout': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto auto auto auto";
+            readonly areas: "\n        \"header header header\"\n        \"top top top\"\n        \"middle-left middle-center middle-right\"\n        \"bottom-left bottom-left bottom-right\"\n        \"bottom-second bottom-second bottom-second\"\n      ";
+        };
+    };
+    readonly 'left3-right1': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "3fr 1fr";
+            readonly rows: "auto 1fr auto";
+            readonly areas: "\n        \"top top\"\n        \"left right\"\n        \"bottom bottom\"\n      ";
+        };
+    };
+};
+export declare const LAYOUT_PRESETS: {
+    readonly 'all-vertical': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr";
+            readonly rows: "auto";
+            readonly areas: "\"top\"";
+        };
+    };
+    readonly 'top1-bottom3': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top top\"\n        \"bottom-left bottom-center bottom-right\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top top\"\n        \"bottom-left bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2-equal': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top\"\n        \"bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'left1-right2': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"left right-top right-top\"\n        \"left right-bottom right-bottom\"\n      ";
+        };
+    };
+    readonly 'top1-bottom2-left-large': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 2fr";
+            readonly rows: "auto auto";
+            readonly areas: "\n        \"top top\"\n        \"bottom-left bottom-right\"\n      ";
+        };
+    };
+    readonly 'dashboard-layout': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "1fr 1fr 1fr";
+            readonly rows: "auto auto auto auto auto";
+            readonly areas: "\n        \"header header header\"\n        \"top top top\"\n        \"middle-left middle-center middle-right\"\n        \"bottom-left bottom-left bottom-right\"\n        \"bottom-second bottom-second bottom-second\"\n      ";
+        };
+    };
+    readonly 'left3-right1': {
+        readonly name: string;
+        readonly description: string;
+        readonly areas: GridArea[];
+        readonly gridTemplate: {
+            readonly columns: "3fr 1fr";
+            readonly rows: "auto 1fr auto";
+            readonly areas: "\n        \"top top\"\n        \"left right\"\n        \"bottom bottom\"\n      ";
+        };
+    };
+};
+export declare function normalizeLayoutPreset(preset?: string | null): LayoutPreset;
+export declare function getVisibleAreas(preset: LayoutPreset): GridArea[];
+export declare function getAreaDisplayName(area: GridArea): string;
+export declare function getAreaDescription(area: GridArea): string;
+export declare function distributeComponentsToAreas(components: any[], preset: LayoutPreset): ComponentItem[];
+export declare function getLayoutContainerClass(preset: LayoutPreset): string;
+export declare function getAreaClass(area: GridArea): string;

package/dist/components/internal/workbench/utils/navigationUtils.d.ts

@@ -0,0 +1,70 @@
+import { NavigationItem } from '../types';
+import { VisibleWhenContext } from './visibleWhen';
+
+/** NavigationItem.title may be a plain string or inline bilingual `{ zh, en }` — always display through this. */
+export declare const navigationTitleText: (title: NavigationItem["title"] | undefined) => string;
+export declare const getNavigationTargetPageId: (item: NavigationItem) => string | null;
+export type NavigationDevice = 'desktop' | 'mobile';
+export declare const isNavigationItemVisibleToMember: (item: NavigationItem, currentMemberId?: string | null, device?: NavigationDevice, visibleWhenContext?: VisibleWhenContext) => boolean;
+export declare const stripNavigationSystemParams: (params: Record<string, unknown>) => Record<string, unknown>;
+export declare const findNavigationItemsForPage: (navigationItems: NavigationItem[] | undefined | null, pageId: string) => NavigationItem[];
+export declare const filterNavigationItemsForMember: (items: NavigationItem[], currentMemberId?: string | null, device?: NavigationDevice, visibleWhenContext?: VisibleWhenContext) => NavigationItem[];
+/** Build URL params for programmatic page open (List/Table navigate, open-tab event). */
+export declare const resolveNavigationOpenParams: (navigationItems: NavigationItem[] | undefined | null, targetPageId: string, actionParams?: Record<string, unknown>) => Record<string, unknown>;
+export type NavigationRouteAccessResult = {
+    allowed: true;
+    matchedItem: NavigationItem | null;
+    targetPageId: string;
+    normalizedQueryString: string | null;
+} | {
+    allowed: false;
+    matchedItem: NavigationItem | null;
+    targetPageId: string;
+    normalizedQueryString: string | null;
+};
+export declare const resolveNavigationRouteAccess: ({ items, routePageId, routeParams, currentMemberId, visibleWhenContext, }: {
+    items: NavigationItem[];
+    routePageId: string;
+    routeParams: Record<string, unknown>;
+    currentMemberId?: string | null;
+    visibleWhenContext?: VisibleWhenContext;
+}) => NavigationRouteAccessResult;
+export declare const calculateNavigationLevels: (items: NavigationItem[], parentKey?: string, level?: number) => NavigationItem[];
+export declare const validateNavigationHierarchy: (items: NavigationItem[]) => {
+    isValid: boolean;
+    errors: string[];
+};
+export declare const findNavigationItem: (items: NavigationItem[], key: string) => NavigationItem | null;
+export declare const findParentItem: (items: NavigationItem[], childKey: string) => NavigationItem | null;
+export declare const addNavigationItem: (items: NavigationItem[], newItem: Omit<NavigationItem, "level" | "hasChildren">, parentKey?: string) => NavigationItem[];
+export declare const removeNavigationItem: (items: NavigationItem[], keyToRemove: string) => NavigationItem[];
+export declare const flattenNavigationItems: (items: NavigationItem[]) => NavigationItem[];
+export declare const getUsedPageKeys: (items: any[]) => Set<string>;
+export declare const getAvailablePages: (allPages: any[], navigationItems: any[]) => any[];
+export declare const getConfiguredPageKeys: (allPageKeys: string[], navigationItems: any[]) => string[];
+/** First matching nav item whose linked page or key equals {@param pageId} (DFS). */
+export declare const findNavigationKeyForPage: (navigationItems: NavigationItem[] | undefined | null, pageId: string) => string | null;
+/** Same encoding rules as TabManager route sync (omit communication-only trigger params). */
+export declare const serializeWorkbenchUrlSearchParams: (params: Record<string, unknown>) => string;
+export type DefaultLandingResolved = {
+    pageId: string;
+    /** Includes leading `?` when non-empty. */
+    queryString: string;
+};
+/** Resolves default landing URL from appConfig; omitting defaultOpenType uses page mode (backward compatible). */
+export declare const resolveDefaultWorkbenchLanding: (appConfig: {
+    defaultOpenType?: string;
+    defaultPage?: string;
+    defaultNavigationKey?: string;
+    navigation?: {
+        items?: NavigationItem[];
+    };
+} | undefined, pages: Record<string, unknown> | undefined, currentMemberId?: string | null, options?: {
+    fallback?: "default" | "navigation";
+    visibleWhenContext?: VisibleWhenContext;
+}) => DefaultLandingResolved | null;
+/** Leaf navigation rows for default-open dropdowns (`titlePath` shows hierarchy). */
+export declare const flattenLeafNavigationOptions: (items: NavigationItem[], titlePath?: string[]) => {
+    key: string;
+    titlePath: string;
+}[];

package/dist/components/internal/workbench/utils/navigationVisibleWhenEditor.d.ts

@@ -0,0 +1,37 @@
+import { VisibleWhen } from './visibleWhen';
+
+/**
+ * Editor-facing helpers for the navigation item visibleWhen condition.
+ *
+ * The sidebar editor offers a role multi-select only, serialized as
+ * `{ rules: [{ source: 'role', field: 'app', op: 'in', value: [...codes] }] }`.
+ * Existing conditions of any other shape (compound or/notIn rules, other fields/sources)
+ * cannot map onto that whitelist: they are shown as a read-only "custom rule in place"
+ * note and must round-trip untouched unless the user actually toggles a role — so
+ * detection below is intentionally strict about which shapes count as simple.
+ */
+export type NavigationVisibleWhenEditState = {
+    kind: 'none';
+} | {
+    kind: 'simple';
+    roleCodes: string[];
+} | {
+    kind: 'custom';
+};
+/** Classify an existing condition: absent, exactly the simple role-gate shape, or custom. */
+export declare const describeNavigationVisibleWhen: (cond: VisibleWhen | undefined | null) => NavigationVisibleWhenEditState;
+/** Whether the condition is a non-simple shape the role picker cannot represent. */
+export declare const hasCustomNavigationVisibleWhen: (cond: VisibleWhen | undefined | null) => boolean;
+/** Serialize the role selection: empty selection means unrestricted (field removed). */
+export declare const buildSimpleRoleVisibleWhen: (roleCodes: string[]) => VisibleWhen | undefined;
+/**
+ * Resolve the visibleWhen to persist from the edit form; undefined removes the field.
+ * An untouched custom condition (`visibleWhenOriginal` present, no role toggled) is
+ * preserved verbatim; once any role checkbox is toggled the item follows the simple
+ * role-selection semantics (empty selection removes the field).
+ */
+export declare const resolveEditFormVisibleWhen: (form: {
+    visibleRoleCodes?: string[];
+    visibleWhenOriginal?: VisibleWhen;
+    visibleRolesTouched?: boolean;
+}) => VisibleWhen | undefined;

package/dist/components/internal/workbench/utils/parameterUtils.d.ts

@@ -0,0 +1,52 @@
+export interface CustomField {
+    fieldName: string;
+    displayName: string;
+}
+export interface ComponentEmitConfig {
+    componentId: string;
+    componentType: string;
+    triggers: Record<string, {
+        enabled: boolean;
+    }>;
+    customEmitFields?: Record<string, CustomField[]>;
+}
+export declare function collectAvailableParameters(pageComponents: any[]): Array<{
+    value: string;
+    label: string;
+    source: string;
+    category: 'builtin' | 'custom';
+}>;
+export declare function isCustomFieldParameter(paramName: string): boolean;
+export declare function extractFieldNameFromParameter(paramName: string): string | null;
+export declare function inferParameterType(value: any): any;
+export declare function parseParameters(params: Record<string, any>): Record<string, any>;
+export declare function extractParametersFromFilters(parameterFilters: Array<{
+    parameterName?: string;
+    enabled?: boolean;
+}>): string[];
+export declare function extractParametersFromString(conditionString: string): string[];
+export declare function mergeListenParameters(manualListenParameters: string[], autoListenParameters: string[]): {
+    finalListenParameters: string[];
+    manualOnly: string[];
+    autoOnly: string[];
+};
+export declare function collectFilterPanelParameters(pageComponents: any[]): Array<{
+    value: string;
+    label: string;
+    source: string;
+    type: string;
+    parent?: string;
+}>;
+export declare function extractFilterPanelDefaultValues(pageComponents: any[], filterPanelId?: string): Record<string, any>;
+export declare const ParameterUtils: {
+    inferParameterType: typeof inferParameterType;
+    parseParameters: typeof parseParameters;
+    collectAvailableParameters: typeof collectAvailableParameters;
+    isCustomFieldParameter: typeof isCustomFieldParameter;
+    extractFieldNameFromParameter: typeof extractFieldNameFromParameter;
+    extractParametersFromFilters: typeof extractParametersFromFilters;
+    extractParametersFromString: typeof extractParametersFromString;
+    mergeListenParameters: typeof mergeListenParameters;
+    collectFilterPanelParameters: typeof collectFilterPanelParameters;
+    extractFilterPanelDefaultValues: typeof extractFilterPanelDefaultValues;
+};

package/dist/components/internal/workbench/utils/redirectToAppHome.d.ts

@@ -0,0 +1,4 @@
+export declare function getAppBaseUrl(): string;
+export declare function getConsoleBaseUrl(): string;
+export declare function redirectToAppHome(): void;
+export declare function redirectToApplications(): void;

package/dist/components/internal/workbench/utils/resolveComponentMockFields.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resolves component mock config (root-level and props) so renderers still see mock/chart fields
+ * when only props change (e.g. chartColorScheme).
+ *
+ * See also:
+ * - ~/memory/knowledge/workbench-useMockData.md
+ * - apps/workbench/docs/useMockData-conventions.md
+ */
+export interface ComponentMockSource {
+    useMockData?: boolean;
+    mockData?: unknown;
+    props?: Record<string, unknown>;
+}
+export declare function resolveUseMockData(component: ComponentMockSource | null | undefined): boolean;
+/** Normalize before save: set root useMockData true when rows exist unless explicitly disabled */
+export declare function normalizeComponentMockFlags<T extends ComponentMockSource>(component: T): T;
+/**
+ * Merge parent pageConfig into local state: parent wins; keep local mock/chart props parent lacks.
+ */
+export declare function mergePageComponentConfig<T extends ComponentMockSource & {
+    id?: string;
+    props?: Record<string, unknown>;
+}>(parent: T, local: T): T;
+/** Normalize mockData / props.mockData to an array of row objects for charts */
+export declare function resolveMockDataRows(component: ComponentMockSource | null | undefined): Record<string, unknown>[];
+/** Single-row mock object for Form display mode and HeroCard */
+export declare function resolveComponentMockRecord(component: ComponentMockSource | null | undefined): Record<string, unknown>;
+export declare function normalizeMockDataRows(raw: unknown): Record<string, unknown>[];

package/dist/components/internal/workbench/utils/resolveDatabaseDataSourceConfig.d.ts

@@ -0,0 +1,9 @@
+import { DatabaseDataSourceConfig } from '../types/databaseDataSource';
+
+type ComponentLike = {
+    databaseDataSourceConfig?: unknown;
+    props?: Record<string, unknown>;
+};
+/** Resolve database datasource config from component root or props (legacy configs may store it under props) */
+export declare function resolveDatabaseDataSourceConfig(component: ComponentLike | null | undefined): DatabaseDataSourceConfig | null;
+export {};

package/dist/components/internal/workbench/utils/safeMessaging.d.ts

@@ -0,0 +1,16 @@
+export declare const safePostMessage: (target: Window | Worker | MessagePort | BroadcastChannel, message: any, targetOrigin?: string) => boolean;
+export declare const safeAddEventListener: (target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => boolean;
+export declare const safeRemoveEventListener: (target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => boolean;
+export declare const safeDispatchEvent: (target: EventTarget, event: Event) => boolean;
+export declare const safeLocalStorage: {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => boolean;
+    removeItem: (key: string) => boolean;
+};
+export declare const safeFetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response | null>;
+export declare const safeDOMOperation: <T>(operation: () => T, fallback?: T) => T | undefined;
+export declare const checkExtensionConflicts: () => {
+    hasConflicts: boolean;
+    conflicts: string[];
+    recommendations: string[];
+};

package/dist/components/internal/workbench/utils/statisticColors.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties } from 'react';
+
+export interface ResolveStatisticColorOptions {
+    mode: 'value' | 'icon';
+    fallbackLegacy?: string;
+}
+export declare function resolveStatisticColor(value: string | undefined, opts: ResolveStatisticColorOptions): {
+    className?: string;
+    style?: CSSProperties;
+};
+export declare const STATISTIC_SEMANTIC_COLOR_KEYS: string[];

package/dist/components/internal/workbench/utils/statisticIcons.d.ts

@@ -0,0 +1,5 @@
+export interface StatisticIconOption {
+    value: string;
+    label: string;
+}
+export declare function getStatisticIconOptions(): StatisticIconOption[];

package/dist/components/internal/workbench/utils/styleUtils.d.ts

@@ -0,0 +1,35 @@
+import { CustomStylesConfig } from '../types/components';
+
+export declare const validateCustomCssSafety: (cssCode: string) => {
+    isSafe: boolean;
+    error?: string;
+};
+export declare const styleObjectToCss: (styleObj: React.CSSProperties) => string;
+export declare const getResponsiveStyles: (responsiveStyles?: {
+    [breakpoint: string]: React.CSSProperties;
+}) => React.CSSProperties;
+export declare const injectCustomCSS: (uniqueId: string, styles: CustomStylesConfig) => void;
+export declare const removeCustomCSS: (uniqueId: string) => void;
+export declare const applyCustomStyles: (componentId: string, customStyles?: CustomStylesConfig, baseClassName?: string) => {
+    className: string;
+    style: React.CSSProperties;
+};
+export declare const mergeStyleConfigs: (base?: CustomStylesConfig, override?: CustomStylesConfig) => CustomStylesConfig;
+export declare const validateStyleConfig: (styles: CustomStylesConfig) => {
+    isValid: boolean;
+    errors: string[];
+};
+export declare const getStylePresets: () => {
+    [key: string]: {
+        name: string;
+        styles: CustomStylesConfig;
+    };
+};
+export declare const STYLE_PRESETS: {
+    [key: string]: {
+        name: string;
+        styles: CustomStylesConfig;
+    };
+};
+/** Resolves spacing prop (number or CSS length) to a CSS length string. */
+export declare function resolveGapCSSValue(gap: string | number | undefined | null): string | undefined;

package/dist/components/internal/workbench/utils/systemParameters.d.ts

@@ -0,0 +1,8 @@
+export type SystemParameterType = 'userId' | 'userName' | 'email' | 'phone';
+export declare const SYSTEM_PARAMETERS: Array<{
+    value: SystemParameterType;
+    label: string;
+}>;
+export declare function getSystemParameterValue(paramType: SystemParameterType, userContext?: {
+    user: unknown;
+} | null): string;

package/dist/components/internal/workbench/utils/tabIsolation.d.ts

@@ -0,0 +1,34 @@
+export declare class TabIsolationManager {
+    private static instance;
+    private tabId;
+    private storagePrefix;
+    private eventListeners;
+    private constructor();
+    static getInstance(): TabIsolationManager;
+    private generateTabId;
+    getTabId(): string;
+    getStorageKey(key: string): string;
+    setItem(key: string, value: string): void;
+    getItem(key: string): string | null;
+    removeItem(key: string): void;
+    clearTabStorage(): void;
+    dispatchTabEvent(eventType: string, detail?: any): void;
+    addTabEventListener(eventType: string, listener: EventListener): void;
+    removeTabEventListener(eventType: string, listener: EventListener): void;
+    sendCrossTabMessage(type: string, data: any): void;
+    onCrossTabMessage(callback: (message: {
+        type: string;
+        data: any;
+        fromTabId: string;
+        timestamp: number;
+    }) => void): void;
+    private handleStorageChange;
+    private clearWorkbenchRelatedStorage;
+    private cleanup;
+    getActiveTabIds(): string[];
+    cleanupClosedTabs(): void;
+    private cleanupTabData;
+    updateLastActive(): void;
+    startHeartbeat(): void;
+}
+export declare const tabIsolation: TabIsolationManager;