@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/app/types/taskExecution.d.ts

@@ -0,0 +1,26 @@
+export interface TaskExecution {
+    id: string;
+    taskId: string;
+    userId: string;
+    spaceId: string;
+    taskType: string;
+    startTime: string;
+    endTime?: string;
+    status: 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELED' | 'RETRY';
+    outputs?: Record<string, unknown>;
+    logs?: Array<{
+        level: 'INFO' | 'WARNING' | 'ERROR' | 'DEBUG';
+        message: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    currentNodeId?: string;
+    error?: string;
+}
+export interface LogEntry {
+    id: string;
+    level: string;
+    message: string;
+    metadata: Record<string, unknown>;
+    timestamp: string;
+    executionId: string;
+}

package/dist/components/assets/maps/bundledMapGeo.d.ts

@@ -0,0 +1,4 @@
+export type BundledMapGeo = Record<string, unknown>;
+export declare function getBundledChinaGeo(): BundledMapGeo;
+export declare function getBundledUsaGeo(): BundledMapGeo;
+export declare function getBundledEuropeGeo(): BundledMapGeo;

package/dist/components/config/communicationIcons.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+
+export type IconName = keyof typeof COMMUNICATION_ICONS;
+export type IconComponent = React.ComponentType<{
+    className?: string;
+    size?: number | string;
+}>;
+export interface IconCategory {
+    name: string;
+    label: string;
+    description: string;
+    icons: IconName[];
+}
+export declare const COMMUNICATION_ICONS: Record<string, IconComponent>;
+export declare const ICON_CATEGORIES: IconCategory[];
+export declare const getIcon: (iconName: string, defaultIcon?: IconName) => IconComponent;
+export declare const getIconsByCategory: (categoryName: string) => IconName[];
+export declare const getAllIconNames: () => IconName[];
+export declare const isValidIconName: (iconName: string) => iconName is IconName;
+export declare const getRecommendedIconsForTriggerCategory: (category: string) => IconName[];
+export declare const createIconComponent: (iconName: string, className?: string) => React.ReactElement;
+export declare const LEGACY_ICON_MAP: Record<string, IconName>;
+export declare const convertLegacyIconName: (legacyName: string) => IconName;

package/dist/components/config/componentTriggers.d.ts

@@ -0,0 +1,70 @@
+import { ComponentTypeDefinition, ParameterDefinition, ComponentTrigger } from '../types/communication';
+
+export declare const COMMON_PARAMETERS: Record<string, ParameterDefinition>;
+export declare const COMMUNICATION_ONLY_PARAMETERS: readonly ["lastTaskResult", "tableRefreshTrigger", "chartRefreshTrigger", "listRefreshTrigger", "treeRefreshTrigger", "lastFormResult", "dataChangeNotification", "formValidationState", "formDataChanged", "taskStatusChanged", "currentTaskInfo", "selectedTreeNode"];
+export declare const isCommunicationOnlyParameter: (parameterKey: string) => boolean;
+export declare const COMPONENT_TRIGGERS: Record<string, ComponentTypeDefinition>;
+export declare const getComponentTriggers: (componentType: string) => ComponentTypeDefinition | null;
+export declare const getAllAvailableParameters: () => ParameterDefinition[];
+export declare const getParametersByCategory: (category: string) => ParameterDefinition[];
+export declare const getCommonParameters: () => ParameterDefinition[];
+export declare const getTriggersByComponent: (componentType: string) => ComponentTrigger[];
+export declare const getParameterDefinition: (parameterKey: string) => ParameterDefinition | null;
+export declare const getComponentTypes: () => ComponentTypeDefinition[];
+export declare const getComponentsByCategory: (category: string) => ComponentTypeDefinition[];
+/**
+ * Base key for the "global action succeeded" trigger. Concrete instances
+ * append a dot-separated escaped actionId (e.g. `onGlobalActionSuccess.approve`).
+ * The bare base key is preserved as a fallback for callers that want to
+ * subscribe once to "any global action success" without per-button config.
+ */
+export declare const ON_GLOBAL_ACTION_SUCCESS_BASE = "onGlobalActionSuccess";
+/**
+ * Replace characters that would break the dot-separated trigger key with
+ * `_`. Currently only `.` matters because we use dots as the separator,
+ * but this function is the single source of truth — if the separator ever
+ * changes, only this function needs updating.
+ */
+export declare function escapeActionIdForTrigger(actionId: string): string;
+/**
+ * Build the trigger key for a given global action. Use the same function on
+ * both the renderer side (when emitting) and the editor side (when deriving
+ * the trigger list) so they always agree.
+ */
+export declare function globalActionSuccessTriggerKey(actionId: string): string;
+/**
+ * Build the per-action trigger list from a Table's `actions` array.
+ * Only `position: 'global'` actions are included. Returns an empty array
+ * when no actions are provided so the caller can safely concatenate.
+ */
+export declare function getGlobalActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];
+/**
+ * Base key for the "row action succeeded" trigger. Concrete instances
+ * append a dot-separated escaped actionId (e.g. `onRowActionSuccess.edit`).
+ */
+export declare const ON_ROW_ACTION_SUCCESS_BASE = "onRowActionSuccess";
+/**
+ * Build the trigger key for a given row action.
+ */
+export declare function rowActionSuccessTriggerKey(actionId: string): string;
+/**
+ * Build the per-action trigger list from a Table's `actions` array.
+ * Only non-global (`position !== 'global'`) actions are included.
+ */
+export declare function getRowActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];
+/**
+ * Merge global and row per-button success triggers for the communication panel.
+ */
+export declare function getPerButtonActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];

package/dist/components/constants/tableActionButtonStyle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Table / EditableTable action button styles: shared by property panel options, i18n fallbacks,
+ * help route, and TableRenderer behavior. (Not help-only; help content reuses the same variant list.)
+ */
+export declare const TABLE_ACTION_BUTTON_STYLE_HELP_PATH: "/help/table-action-button-style";
+export declare const TABLE_ACTION_BUTTON_STYLE_VARIANTS: readonly ["default", "destructive", "outline", "secondary", "approve", "reject", "success", "warning", "info"];
+export type TableActionButtonStyleVariant = (typeof TABLE_ACTION_BUTTON_STYLE_VARIANTS)[number];
+/** English fallbacks for useTranslation('editor') keys table_property_editor.button_style_*; matches t(key, default) second arg */
+export declare const TABLE_ACTION_BUTTON_STYLE_LABEL_FALLBACK: Record<TableActionButtonStyleVariant, string>;
+/**
+ * Action types that open `ActionFormDialog` when `TableRenderer` has `inputMode === 'form'`.
+ * The property panel should align when showing direct vs form confirm and form options (incl. DB insert/delete, etc.).
+ */
+export declare const TABLE_ACTION_TYPES_WITH_FORM_MODE: readonly ["updateDataset", "insertDataset", "updateDatabase", "insertDatabase", "deleteDatabase", "transactionDatabase"];
+export declare function tableActionSupportsFormMode(type: string): boolean;

package/dist/components/contexts/PageFullscreenContext.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+export declare const PageFullscreenProvider: React.Provider<boolean>;
+export declare function usePageFullscreen(): boolean;

package/dist/components/contexts/ParameterContext.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { ParameterContextValue, ParameterRecord, ParameterParseConfig, ParameterValue } from '../types/parameters';
+
+declare const ParameterContext: React.Context<ParameterContextValue>;
+export { ParameterContext };
+interface ParameterProviderProps {
+    children: React.ReactNode;
+    tabId: string;
+    pageId: string;
+    initialParams?: ParameterRecord;
+}
+export declare const parseUrlParameters: (config?: ParameterParseConfig) => ParameterRecord;
+export declare const ParameterProvider: React.FC<ParameterProviderProps>;
+export declare const useParameterContext: () => ParameterContextValue;
+export declare const usePageParameters: () => ParameterRecord;
+export declare const useParameter: (key: string) => ParameterValue;
+export declare const useParameters: (keys: string[]) => Record<string, any>;
+export declare const clearAllTabParameters: () => void;

package/dist/components/contexts/TabActivityContext.d.ts

@@ -0,0 +1,2 @@
+export declare const TabActivityProvider: import('react').Provider<boolean>;
+export declare function useTabActivity(): boolean;

package/dist/components/contexts/ViewportContext.d.ts

@@ -0,0 +1,19 @@
+import { default as React, ReactNode } from 'react';
+import { ViewportMode, ViewportSource } from '../mobile/utils/getMobileViewportState';
+
+export type { ViewportMode };
+interface ViewportContextValue {
+    mode: ViewportMode;
+    isMobile: boolean;
+    /** True when on desktop browser with a manual mobile preview override. */
+    canReturnToDesktop: boolean;
+    viewportSource: ViewportSource;
+    isWeCom: boolean;
+    forceMobile: () => void;
+    forceDesktop: () => void;
+    reset: () => void;
+}
+export declare function ViewportProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useViewport(): ViewportContextValue;

package/dist/components/contexts/WorkbenchConfigLocaleContext.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { PageConfig } from '../types/components';
+import { WorkbenchConfigWithLocales, WorkbenchLocaleMetadata } from '../utils/workbenchConfigLocale';
+import { LocaleLabelMap } from '../utils/workbenchDisplayLocale';
+
+type WorkbenchConfigLocaleContextValue = {
+    language: string;
+    metadata: WorkbenchLocaleMetadata | undefined;
+    labelMap: LocaleLabelMap | undefined;
+    localizeText: (text: string | null | undefined) => string;
+    resolveBilingualText: (text: unknown) => string;
+    localizeRows: <T extends Record<string, unknown>>(rows: T[] | null | undefined) => T[];
+    localizeWorkbenchConfig: (config: WorkbenchConfigWithLocales | null | undefined) => WorkbenchConfigWithLocales | null | undefined;
+    localizeAppConfig: <T extends Record<string, unknown>>(appConfig: T | undefined) => T | undefined;
+    localizePageConfig: <T extends Record<string, unknown>>(pageId: string, pageConfig: T | undefined) => T | undefined;
+};
+export declare const WorkbenchConfigLocaleProvider: React.FC<{
+    metadata: WorkbenchLocaleMetadata | undefined;
+    children: React.ReactNode;
+}>;
+export declare const useWorkbenchConfigLocale: () => WorkbenchConfigLocaleContextValue;
+export declare const useLocalizedPageConfig: (pageId: string, pageConfig: PageConfig | undefined) => PageConfig | undefined;
+export {};

package/dist/components/contexts/WorkbenchGlobalSpaceContext.d.ts

@@ -0,0 +1,10 @@
+import { default as React, ReactNode } from 'react';
+import { useSpace } from '../shared/platform-ui/index.ts';
+
+type WorkbenchGlobalSpaceContextValue = ReturnType<typeof useSpace>;
+export declare function WorkbenchGlobalSpaceProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useWorkbenchGlobalSpace(): WorkbenchGlobalSpaceContextValue;
+export declare function useWorkbenchGlobalSpaceOptional(): WorkbenchGlobalSpaceContextValue | null;
+export {};

package/dist/components/contexts/WorkbenchThemeContext.d.ts

@@ -0,0 +1,23 @@
+import { default as React, ReactNode } from 'react';
+import { ThemeId, Theme } from '../themes';
+
+interface WorkbenchThemeContextValue {
+    themeId: ThemeId;
+    setThemeId: (id: ThemeId) => Promise<void>;
+    theme: Theme;
+    isDark: boolean;
+}
+export interface WorkbenchThemeProviderProps {
+    children: ReactNode;
+    workbenchId?: string;
+    serverThemeId?: string | undefined;
+    /**
+     * Persist theme into `Workbench.config` (merge `{ ...config, themeId }`).
+     * When omitted, viewers prefer locally saved preferences before server defaults.
+     */
+    onPersistTheme?: (themeId: ThemeId) => Promise<void>;
+}
+export declare function WorkbenchThemeProvider({ children, workbenchId, serverThemeId, onPersistTheme, }: WorkbenchThemeProviderProps): React.JSX.Element;
+/** Appearance package (`classic` / `inkOnyx`, …); unrelated to `@genispace/shared-ui` light/dark controls. */
+export declare function useWorkbenchTheme(): WorkbenchThemeContextValue;
+export {};

package/dist/components/dialogs/TaskParamsDialog.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+
+interface TaskParamsDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    taskId: string;
+    initialParams?: Record<string, unknown>;
+    onSuccess?: (result: {
+        id?: string;
+        executionId?: string;
+        [key: string]: unknown;
+    }) => void;
+    onError?: (error: Error) => void;
+    title?: string;
+    description?: string;
+}
+declare const TaskParamsDialog: React.FC<TaskParamsDialogProps>;
+export default TaskParamsDialog;

package/dist/components/dialogs/TreeFormDialog.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { InsertDatasetConfig, UpdateDatasetConfig } from '../types';
+import { ColumnConfig } from '../types/editor';
+
+interface TreeFormDialogProps {
+    isOpen: boolean;
+    mode: 'add' | 'edit';
+    onClose: () => void;
+    onSubmit: (data: Record<string, any>) => void;
+    insertConfig?: InsertDatasetConfig;
+    updateConfig?: UpdateDatasetConfig;
+    treeColumns: ColumnConfig[];
+    selectedNode?: any;
+    selectedParent?: any;
+    parentKey?: string;
+    availableParameters?: Array<{
+        label: string;
+        value: string;
+        type?: string;
+    }>;
+}
+export declare const TreeFormDialog: React.FC<TreeFormDialogProps>;
+export {};

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

@@ -0,0 +1,6 @@
+export { useComponentCommunication, useParameterEmitter, useParameterListener, } from './useComponentCommunication';
+export type { ComponentCommunicationConfig, ComponentCommunicationReturn, } from './useComponentCommunication';
+export { useParameterHandler, buildDataSourceFilters, buildFilterString, mergeFilterStrings, parseUrlParameters, } from './useParameterHandler';
+export { useEnhancedDataSource } from './useEnhancedDataSource';
+export type { UseEnhancedDataSourceOptions, UseEnhancedDataSourceReturn, } from './useEnhancedDataSource';
+export { usePageAutoRefresh } from './usePageAutoRefresh';

package/dist/components/hooks/useComponentCommunication.d.ts

@@ -0,0 +1,27 @@
+import { ParameterValue, ParameterChangeEvent } from '../types/parameters';
+
+export interface ComponentCommunicationConfig {
+    componentId: string;
+    emitParameters?: string[];
+    listenParameters?: string[];
+    onParameterChange?: (key: string, value: ParameterValue, event: ParameterChangeEvent) => void;
+    autoCleanup?: boolean;
+    immediate?: boolean;
+}
+export interface ComponentCommunicationReturn {
+    emit: (key: string, value: ParameterValue) => void;
+    emitBatch: (params: Record<string, ParameterValue>) => void;
+    getCurrentParameter: (key: string) => ParameterValue;
+    getAllParameters: () => Record<string, ParameterValue>;
+    subscribe: (keys: string[], callback: (event: ParameterChangeEvent) => void) => () => void;
+    hasListeners: (key: string) => boolean;
+}
+export declare const useComponentCommunication: (config: ComponentCommunicationConfig) => ComponentCommunicationReturn;
+export declare const useParameterEmitter: (componentId: string, allowedParameters?: string[]) => {
+    emit: (key: string, value: ParameterValue) => void;
+    emitBatch: (params: Record<string, ParameterValue>) => void;
+};
+export declare const useParameterListener: (componentId: string, parameters: string[], callback: (key: string, value: ParameterValue, event: ParameterChangeEvent) => void) => {
+    getCurrentParameter: (key: string) => ParameterValue;
+    getAllParameters: () => Record<string, ParameterValue>;
+};

package/dist/components/hooks/useConditionMapper.d.ts

@@ -0,0 +1,17 @@
+import { UpdateDatabaseConfig } from '../types';
+
+export declare const useConditionMapper: (updateConditions: UpdateDatabaseConfig["updateConditions"], onChange: (conditions: UpdateDatabaseConfig["updateConditions"]) => void) => {
+    isCollapsed: boolean;
+    setIsCollapsed: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    handleAddCondition: (fieldName: string, initialConfig?: Partial<UpdateDatabaseConfig["updateConditions"][string]>) => boolean;
+    handleRemoveCondition: (fieldName: string) => void;
+    handleConditionChange: (fieldName: string, key: string, value: string) => void;
+    handleFieldRename: (oldName: string, newName: string) => boolean;
+    getConditionStats: () => {
+        total: number;
+        hasStatic: boolean;
+        hasParameter: boolean;
+        hasColumn: boolean;
+        hasInputField: boolean;
+    };
+};

package/dist/components/hooks/useCurrentUser.d.ts

@@ -0,0 +1,10 @@
+export interface CurrentUserInfo {
+    id: string;
+    name: string;
+    email: string;
+}
+export declare function useCurrentUser(): {
+    currentUser: CurrentUserInfo;
+    loading: boolean;
+    error: any;
+};

package/dist/components/hooks/useDatabaseDataSource.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseDataSourceConfig, UseDatabaseDataSourceReturn, SupportedComponentType, ErrorHandlingConfig, PerformanceConfig } from '../types/databaseDataSource';
+
+export declare const useDatabaseDataSource: (config: DatabaseDataSourceConfig | null, componentType: SupportedComponentType, additionalParams?: Record<string, any>, options?: {
+    errorConfig?: Partial<ErrorHandlingConfig>;
+    performanceConfig?: Partial<PerformanceConfig>;
+    autoFetch?: boolean;
+}) => UseDatabaseDataSourceReturn;
+export default useDatabaseDataSource;

package/dist/components/hooks/useDatasourceVersionBindings.d.ts

@@ -0,0 +1,24 @@
+import { WorkbenchConfigData } from '../types';
+
+/**
+ * Non-default datasource version bindings of a workbench config — shared by the
+ * EditModeToolbar badge (count) and the PublishDialog binding list.
+ *
+ * A pin counts as non-default when the pinned version differs from the
+ * datasource's current default, or when the pinned version no longer exists.
+ * Single POST /datasources/versions/batch call — it returns name/identifier
+ * per datasource, so no per-datasource detail fetches are needed.
+ */
+export interface DatasourceVersionBindingInfo {
+    datasourceId: string;
+    name?: string;
+    identifier?: string;
+    pinnedVersion: number;
+    defaultVersion: number | null;
+    /** False when the pinned version was deleted upstream. */
+    pinnedExists: boolean;
+}
+export declare function useNonDefaultDatasourceBindings(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined): {
+    bindings: DatasourceVersionBindingInfo[];
+    loading: boolean;
+};

package/dist/components/hooks/useEnhancedDataSource.d.ts

@@ -0,0 +1,40 @@
+import { EnhancedDataSource } from '../types/datasource';
+
+export interface UseEnhancedDataSourceOptions {
+    dataSource: EnhancedDataSource | null;
+    onDataChange?: (data: any[]) => void;
+    onError?: (error: string) => void;
+    onFilterChange?: (filter: string) => void;
+    componentId?: string;
+    pageSize?: number;
+}
+export interface DatasetPagination {
+    total: number;
+    limit: number;
+    offset: number;
+    current_page: number;
+    total_pages: number;
+    has_more: boolean;
+}
+export interface EnhancedDataSourceRefreshOptions {
+    page?: number;
+    pageSize?: number;
+}
+export interface UseEnhancedDataSourceReturn {
+    data: any[];
+    loading: boolean;
+    error: string | null;
+    pagination: DatasetPagination | undefined;
+    refresh: (options?: EnhancedDataSourceRefreshOptions) => Promise<void>;
+    currentFilter: string;
+    parameterValues: Record<string, any>;
+    filterConditions: string[];
+    exportAllData: (onProgress: (current: number, total: number) => void) => Promise<any[]>;
+}
+export declare function extractDatasetPagination(payload: unknown, fallback: {
+    page: number;
+    pageSize: number;
+    rowCount: number;
+}): DatasetPagination;
+export declare const useEnhancedDataSource: ({ dataSource, onDataChange, onError, onFilterChange, componentId, pageSize: requestedPageSize, }: UseEnhancedDataSourceOptions) => UseEnhancedDataSourceReturn;
+export default useEnhancedDataSource;

package/dist/components/hooks/useMobileViewport.d.ts

@@ -0,0 +1,18 @@
+import { ViewportSource } from '../mobile/utils/getMobileViewportState';
+
+interface UseMobileViewportOptions {
+    wecom?: boolean;
+    debug?: boolean;
+}
+interface UseMobileViewportReturn {
+    mode: 'mobile' | 'desktop';
+    isMobile: boolean;
+    canReturnToDesktop: boolean;
+    viewportSource: ViewportSource;
+    isWeCom: boolean;
+    forceMobile: () => void;
+    forceDesktop: () => void;
+    reset: () => void;
+}
+export declare function useMobileViewport(options?: UseMobileViewportOptions): UseMobileViewportReturn;
+export {};

package/dist/components/hooks/usePageAutoRefresh.d.ts

@@ -0,0 +1,9 @@
+import { PageConfig } from '../types/components';
+
+interface PageAutoRefreshOptions {
+    pageConfig: PageConfig;
+    pageId: string;
+    isActive: boolean;
+}
+export declare const usePageAutoRefresh: ({ pageConfig, pageId, isActive }: PageAutoRefreshOptions) => void;
+export default usePageAutoRefresh;

package/dist/components/hooks/useParameterHandler.d.ts

@@ -0,0 +1,27 @@
+import { ParameterConfig } from '../types';
+import { ParameterRecord, ParameterValue, ComponentParameterConfig, ParameterChangeEvent } from '../types/parameters';
+
+interface UseParameterHandlerProps {
+    parameterConfig?: ParameterConfig;
+    pageParams?: ParameterRecord;
+    componentId?: string;
+    preferProvidedParams?: boolean;
+    componentParameterConfig?: ComponentParameterConfig;
+}
+interface UseParameterHandlerReturn {
+    rawParams: ParameterRecord;
+    getParameterForDataSource: () => ParameterRecord;
+    getParameterForProps: () => ParameterRecord;
+    updateParameter: (key: string, value: ParameterValue) => void;
+    isParameterEnabled: boolean;
+    parameterSource: 'context' | 'provided' | 'none';
+    broadcastParameter: (key: string, value: ParameterValue) => void;
+    subscribeToParameters: (keys: string[], callback: (event: ParameterChangeEvent) => void) => () => void;
+    isListeningToParameters: boolean;
+}
+export declare const useParameterHandler: ({ parameterConfig, pageParams, componentId, preferProvidedParams, componentParameterConfig }: UseParameterHandlerProps) => UseParameterHandlerReturn;
+export declare const buildDataSourceFilters: (filters?: ParameterConfig["dataSourceFilters"], parameters?: ParameterRecord) => ParameterRecord;
+export declare const buildFilterString: (filters?: ParameterRecord, fieldTypes?: Record<string, string>) => string;
+export declare const mergeFilterStrings: (...filters: (string | undefined)[]) => string;
+export declare const parseUrlParameters: () => ParameterRecord;
+export {};

package/dist/components/hooks/useReleaseNotesPrompt.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Release-notes prompt state ("new version published" dialog), shared by the
+ * desktop (WorkbenchLayout) and mobile (WorkbenchMobileLayout) shells.
+ *
+ * Shows once per user per published version: the dismissal marker lives
+ * server-side in `User.launcherState.releaseNoteDismissals` (a
+ * `{ [workbenchId]: publishedVersion }` map) via `GET/PUT /users/me/settings`
+ * — localStorage is deliberately NOT the source of truth because the WeCom
+ * webview wipes it on re-entry. A bare localStorage key is only an
+ * anti-flicker cache consulted before the settings GET resolves.
+ *
+ * Writes are deliberately narrow: `dismiss()` re-fetches settings, then PUTs
+ * ONLY the merged `releaseNoteDismissals` map — echoing back mount-time
+ * snapshots of sibling fields would clobber concurrent writes (e.g. hub's
+ * persistLauncherState); the server preserves fields we don't send and
+ * deep-merges this map per key.
+ *
+ * An unread version is still NOT enough to pop: the prompt only shows when
+ * `GET /workbenches/:id/publish-history?limit=1` returns a real note.
+ * Versions with empty history (publishes predating the history feature,
+ * template/copy-created workbenches) are marked read silently; a failed
+ * history fetch stays quiet without persisting, so the next visit retries.
+ */
+export interface UseReleaseNotesPromptOptions {
+    workbenchId?: string;
+    /** `currentWorkbench.publishedVersion` — absent until the workbench loads. */
+    publishedVersion?: string | null;
+    isEditMode: boolean;
+    isPreviewActive: boolean;
+    /** `UserContext.user.id` — absent until the user profile resolves. */
+    userId?: string | null;
+}
+export interface UseReleaseNotesPromptResult {
+    shouldShow: boolean;
+    /** Close the dialog and persist the dismissal (best-effort, never blocks). */
+    dismiss: () => void;
+}
+export declare function useReleaseNotesPrompt({ workbenchId, publishedVersion, isEditMode, isPreviewActive, userId, }: UseReleaseNotesPromptOptions): UseReleaseNotesPromptResult;

package/dist/components/hooks/useSpaceSwitchHandler.d.ts

@@ -0,0 +1,7 @@
+interface UseSpaceSwitchHandlerOptions {
+    onSpaceSwitch?: () => void;
+    enabled?: boolean;
+}
+export declare const useSpaceSwitchHandler: (options?: UseSpaceSwitchHandlerOptions) => void;
+export declare const useSpaceSwitchRefresh: (refetchFn?: () => void) => void;
+export default useSpaceSwitchHandler;

package/dist/components/hooks/useTaskInputDataSourceCache.d.ts

@@ -0,0 +1,24 @@
+export interface DataSourceConfig {
+    datasourceId: string;
+    version?: number;
+    valueField: string;
+    labelField: string;
+}
+export interface DataSourceOption {
+    value: string;
+    label: string;
+}
+export declare function parseDataSourceConfigFromMapping(mapping: {
+    source?: string;
+    value?: string;
+} | undefined): DataSourceConfig | null;
+export declare function useTaskInputDataSourceCache(parameterMapping: Record<string, {
+    source?: string;
+    value?: string;
+}> | undefined, schemaLoaded: boolean): {
+    getOptionsForConfig: (config: DataSourceConfig | null) => DataSourceOption[];
+    parseDataSourceConfig: (mapping: {
+        source?: string;
+        value?: string;
+    } | undefined) => DataSourceConfig | null;
+};

package/dist/components/hooks/useVisibleWhenContext.d.ts

@@ -0,0 +1,3 @@
+import { VisibleWhenContext } from '../utils/visibleWhen';
+
+export declare function useVisibleWhenContext(pageParams: Record<string, unknown> | undefined): VisibleWhenContext;

package/dist/components/hooks/useWaitForParameters.d.ts

@@ -0,0 +1,9 @@
+interface UseWaitForParametersOptions {
+    onReady?: () => void;
+}
+interface UseWaitForParametersReturn {
+    ready: boolean;
+    isReady: (parameterKeys: string[]) => boolean;
+}
+export declare const useWaitForParameters: (listenParameters: string[] | undefined, options?: UseWaitForParametersOptions) => UseWaitForParametersReturn;
+export default useWaitForParameters;

package/dist/components/hooks/useWorkbenchAppAccess.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Current user's access within the workbench's owning application.
+ * `roles` are the application role CODES assigned to the current user (from
+ * `GET /applications/:id/users/me/access`). Empty when the user has no app roles or the
+ * workbench app has no custom roles yet.
+ */
+export interface WorkbenchAppAccess {
+    isUser: boolean;
+    roles: string[];
+    permissionCodes: string[];
+    loading: boolean;
+    /** The workbench's owning application id (undefined until the workbench config loads). */
+    applicationId?: string;
+}
+export declare function useResolvedApplicationId(): string | undefined;
+export declare function useWorkbenchAppAccess(): WorkbenchAppAccess;

package/dist/components/hooks/useWorkbenchHeaderNavApps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Enabled built-in nav apps + active id for AppHeader (pinned shortcuts, team apps menu).
+ */
+export declare function useWorkbenchHeaderNavApps(displayLanguage?: string): {
+    enabledBuiltInApps: import('../shared/platform-ui/index.ts').EnabledBuiltInAppItem[];
+    activeBuiltInAppId: string;
+};

package/dist/components/hooks/useWorkbenchPreview.d.ts

@@ -0,0 +1,24 @@
+import { WorkbenchConfigView, WorkbenchResponse } from '../app/services/workbenchApi';
+
+export interface ResolvedConfigView {
+    view: WorkbenchConfigView;
+    previewToken?: string;
+}
+export declare function resolveDraftLoadFallback(viewOptions: ResolvedConfigView, error: unknown): {
+    fallbackToPublished: boolean;
+    exitPreview: boolean;
+};
+/**
+ * Shared draft-preview state for the publish flow, consumed by both the desktop
+ * (WorkbenchLayout) and mobile (WorkbenchMobileLayout) shells: resolves which
+ * config view to load (preview link / edit mode / published), tracks whether a
+ * preview is on screen, and handles exiting preview — manually or when the
+ * backend rejects an expired preview token (403 PREVIEW_TOKEN_INVALID).
+ */
+export declare function useWorkbenchPreview(): {
+    resolveConfigView: (id: string) => ResolvedConfigView;
+    exitPreview: (id: string) => void;
+    isPreviewActive: boolean;
+    lastLoadedWorkbenchIdRef: import('react').MutableRefObject<string>;
+    loadWorkbenchWithPreview: (id: string) => Promise<WorkbenchResponse>;
+};