@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/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/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/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/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/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/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/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/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/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/utils/statisticIcons.d.ts

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

package/dist/components/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/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/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;

package/dist/components/utils/tableActionButtonRender.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared Table / List / EditableTable action button visual mapping.
+ * Must stay aligned with help: /help/table-action-button-style
+ */
+export type TableActionButtonPlacement = 'toolbar' | 'row';
+type TableActionButtonVisualVariant = 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'subtle' | 'link';
+export declare function getTableActionButtonVariant(placement: TableActionButtonPlacement, variant?: string): TableActionButtonVisualVariant;
+export declare function getSemanticActionButtonTextColor(variant?: string): string;
+export declare function getTableActionButtonExtraClassName(placement: TableActionButtonPlacement, variant: string | undefined, hasIcon: boolean, hasLabel: boolean): string;
+export declare function getTableActionButtonSize(placement: TableActionButtonPlacement, hasIcon: boolean, hasLabel: boolean): 'sm' | 'icon';
+export declare function getTableActionButtonLayoutClassName(placement: TableActionButtonPlacement, hasIcon: boolean, hasLabel: boolean): string;
+export {};

package/dist/components/utils/taskUtils.d.ts

@@ -0,0 +1,37 @@
+export interface TaskSchema {
+    id: string;
+    name: string;
+    description: string;
+    inputs: Record<string, TaskNodeInput>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface TaskNodeInput {
+    params: Record<string, TaskInputParam>;
+    nodeType: string;
+    nodeName: string;
+    description?: string;
+}
+export interface TaskInputParam {
+    type: string;
+    required: boolean;
+    description: string;
+    default?: unknown;
+    enum?: unknown[];
+    arrayType?: string;
+    maxItems?: number;
+    maxSize?: number;
+    accept?: string;
+}
+export declare function getTaskSchema(taskId: string): Promise<TaskSchema>;
+export declare function getRequiredAndOptionalInputs(schema: TaskSchema): {
+    required: Array<[string, string, TaskInputParam]>;
+    optional: Array<[string, string, TaskInputParam]>;
+};
+export declare function checkTaskParamsFilled(params: Record<string, unknown>, schema: TaskSchema): Array<[string, string, TaskInputParam]>;
+export declare function formatTaskParamsForAPI(formData: Record<string, unknown>): Record<string, Record<string, unknown>>;
+export declare function executeTask(taskId: string, params: Record<string, Record<string, unknown>>): Promise<{
+    id?: string;
+    executionId?: string;
+    [key: string]: unknown;
+}>;

package/dist/components/utils/treeFormUtils.d.ts

@@ -0,0 +1,41 @@
+import { InsertDatasetConfig, UpdateDatasetConfig } from '../types';
+import { ColumnConfig } from '../types/editor';
+
+export interface EnhancedFieldConfig {
+    source: 'column' | 'static' | 'parameter' | 'computed' | 'field' | 'datasource';
+    value: string;
+    required: boolean;
+    fieldType: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'ARRAY';
+    datasourceConfig?: {
+        datasetId: string;
+        valueField: string;
+        labelField: string;
+        filter?: string;
+    };
+}
+export interface TreeFormField {
+    name: string;
+    label: string;
+    type: 'text' | 'number' | 'select' | 'datasource-select' | 'computed-display' | 'switch' | 'textarea';
+    required: boolean;
+    source: EnhancedFieldConfig['source'];
+    config: EnhancedFieldConfig;
+    datasourceOptions?: Array<{
+        value: any;
+        label: string;
+        record: Record<string, any>;
+    }>;
+    computedValue?: any;
+}
+export interface DatasourceOption {
+    value: any;
+    label: string;
+    record: Record<string, any>;
+}
+export declare function parseInsertConfigToFormFields(insertConfig: InsertDatasetConfig, treeColumns: ColumnConfig[]): TreeFormField[];
+export declare function parseUpdateConfigToFormFields(updateConfig: UpdateDatasetConfig, treeColumns: ColumnConfig[]): TreeFormField[];
+export declare function findTreeDisplayField(formFields: TreeFormField[]): TreeFormField | null;
+export declare function validateRequiredFields(formFields: TreeFormField[], formData: Record<string, any>): {
+    isValid: boolean;
+    missingFields: string[];
+};

package/dist/components/utils/visibleWhen.d.ts

@@ -0,0 +1,31 @@
+export type VisibleWhenSource = 'pageParam' | 'role' | 'user';
+export type VisibleWhenOp = 'eq' | 'ne' | 'in' | 'notIn' | 'exists' | 'notExists' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains';
+export interface VisibleWhenRule {
+    source?: VisibleWhenSource;
+    field: string;
+    op?: VisibleWhenOp;
+    value?: unknown;
+}
+export interface VisibleWhen {
+    key?: string;
+    value?: string | string[];
+    notValue?: string | string[];
+    all?: VisibleWhen[];
+    logic?: 'and' | 'or';
+    rules?: VisibleWhenRule[];
+}
+export interface VisibleWhenContext {
+    pageParams?: Record<string, unknown>;
+    user?: {
+        id?: string;
+        name?: string;
+        email?: string;
+    } | null;
+    roles?: {
+        space?: string | null;
+        platform?: string[];
+        app?: string[];
+    };
+}
+export declare function evaluateVisibleWhen(cond: VisibleWhen | undefined | null, ctx: VisibleWhenContext): boolean;
+export declare function isVisibleWhen(cond: VisibleWhen | undefined | null, pageParams: Record<string, unknown> | undefined): boolean;