@genispace/geniapp 0.2.0 → 0.4.0

package/dist/components/internal/workbench/components/renderers/publishPreviewEntryHelpers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure state helpers for PublishPreviewEntryRenderer — kept free of
+ * React/i18n/api imports so the status state machine can be unit-tested in
+ * isolation.
+ *
+ * The component self-sources its data from `GET /workbenches/:id` (default
+ * published view), which returns `hasUnpublishedChanges` plus a
+ * `permissions: { canView, canEdit, canManage }` block.
+ */
+export interface PublishPreviewPermissions {
+    canView?: boolean;
+    canEdit?: boolean;
+    canManage?: boolean;
+}
+/** The subset of the `GET /workbenches/:id` payload this component reads. */
+export interface WorkbenchPublishStatus {
+    hasUnpublishedChanges?: boolean;
+    permissions?: PublishPreviewPermissions;
+}
+export type PublishPreviewEntryStatus = 'loading' | 'error' | 'no-changes' | 'can-preview' | 'no-permission';
+export type PublishPreviewEntryMode = 'preview' | 'edit' | null;
+/**
+ * Mode overrides the three-state display: while previewing (a preview token
+ * exists for this tab) or editing, the "Enter preview" button makes no sense,
+ * so the card shows a fixed mode note instead. Preview wins over edit when
+ * both flags are somehow set — being inside a preview is the more specific
+ * state, and it matches resolveConfigView's token-first order.
+ */
+export declare function resolveEntryMode(input: {
+    isPreviewMode: boolean;
+    isEditMode: boolean;
+}): PublishPreviewEntryMode;
+/** i18n key (renderers.json publish_preview_entry.*) for the fixed mode note. */
+export declare function entryModeNoteKey(mode: PublishPreviewEntryMode): 'mode_preview' | 'mode_edit' | null;
+/** Write access for preview-token creation: edit or manage on the workbench. */
+export declare function canWriteWorkbench(permissions?: PublishPreviewPermissions | null): boolean;
+/**
+ * Resolve the card's display state. Loading and error dominate; without
+ * unpublished changes the entry is informational only; otherwise the button
+ * shows only for users who can create a preview token (write permission).
+ */
+export declare function resolvePublishPreviewEntryStatus(input: {
+    loading: boolean;
+    error: string | null;
+    workbench?: WorkbenchPublishStatus | null;
+}): PublishPreviewEntryStatus;
+/** Preview entry URL — navigating here puts the whole current page into preview mode. */
+export declare function buildWorkbenchPreviewUrl(origin: string, workbenchId: string, token: string): string;
+/** Pull the token out of `createWorkbenchPreviewToken`'s ApiResponse, or null. */
+export declare function extractPreviewToken(response: unknown): string | null;

package/dist/components/internal/workbench/components/renderers/shared/TableEmptyStateWithChromeInsets.d.ts

@@ -0,0 +1,12 @@
+import { ComponentProps } from 'react';
+import { TableEmptyState } from '../../skeleton';
+
+type TableEmptyStateBaseProps = ComponentProps<typeof TableEmptyState>;
+export interface TableEmptyStateWithChromeInsetsProps extends TableEmptyStateBaseProps {
+    /** When true with floatBadge, keep the badge clear of mobile sticky header / bottom nav. */
+    avoidMobileChrome?: boolean;
+    /** Re-measure chrome insets when this changes (e.g. empty state becomes visible). */
+    chromeRemeasureKey?: unknown;
+}
+export declare function TableEmptyStateWithChromeInsets({ avoidMobileChrome, chromeRemeasureKey, floatBadge, ...rest }: TableEmptyStateWithChromeInsetsProps): import("react").JSX.Element;
+export {};

package/dist/components/internal/workbench/components/renderers/shared/ViewToggleButton.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+
+export type ViewType = 'chart' | 'data';
+interface ViewToggleButtonProps {
+    viewType: ViewType;
+    onToggle: () => void;
+    className?: string;
+    /** Desktop uses text labels; mobile defaults to a single icon toggle. */
+    variant?: 'text' | 'icon' | 'auto';
+}
+/** Chart / List shared header toggle — matches ChartRenderer & EChartsChartRenderer. */
+export declare const ViewToggleButton: React.FC<ViewToggleButtonProps>;
+export {};

package/dist/components/internal/workbench/components/renderers/shared/useEscapedStickyPanel.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement, ReactNode } from 'react';
+
+export declare function useEscapedStickyPanel(enabled: boolean, stickyTop?: string): {
+    wrapSticky: (panel: ReactElement) => ReactNode;
+    stuck: boolean;
+};

package/dist/components/internal/workbench/components/renderers/shared/useMobileChromeInsets.d.ts

@@ -0,0 +1,18 @@
+export interface MobileChromeInsets {
+    /** Viewport px occupied by sticky/fixed chrome at the TOP (sticky FilterPanel or mobile header). */
+    top: number;
+    /** Viewport px occupied by fixed chrome at the BOTTOM (the bottom tab nav). */
+    bottom: number;
+}
+/**
+ * Mobile-only: measure the viewport insets taken by fixed/sticky workbench chrome — the sticky
+ * FilterPanel (falling back to the mobile header) at the top and the fixed bottom tab nav at the
+ * bottom. Pass the result to a floating element (e.g. {@link TableEmptyState}'s `floatBadge`) so it
+ * stays inside the content area instead of overlapping that chrome.
+ *
+ * Both values are 0 when `enabled` is false (e.g. desktop). The chrome sits at stable viewport
+ * positions, so we only re-measure on mount, on resize, and whenever `remeasureKey` changes — pass
+ * the "is the floating element visible" flag so insets are refreshed right when they are needed
+ * (the FilterPanel may not be sticky-positioned yet at first mount).
+ */
+export declare function useMobileChromeInsets(enabled: boolean, remeasureKey?: unknown): MobileChromeInsets;

package/dist/components/internal/workbench/components/renderers/shared/useStickyHeaderClone.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Page-level sticky table header for MOBILE, without losing horizontal scroll.
+ *
+ * Why a clone: a table that scrolls horizontally lives inside an `overflow-x:auto`
+ * wrapper. Per CSS, that wrapper is also the vertical scroll container, so a plain
+ * `position: sticky` <thead> can only pin inside that wrapper — never to the page.
+ * So we render a lightweight CLONE of the real <thead> OUTSIDE the horizontal
+ * scroller: `position: sticky; top: var(--wb-filter-sticky-height)` pins it to the
+ * page scrollport right below the sticky FilterPanel; we sync its horizontal offset
+ * to the body's scrollLeft and mirror column widths. (This is what antd's
+ * `Table sticky={{ offsetHeader }}` does under the hood.)
+ *
+ * The hook is markup-agnostic: give it an empty overlay <div> rendered as the first
+ * child of the table card (before the scroll container). It finds the card's <table>
+ * + <thead> + horizontal scroller itself, clones the header, and keeps it in sync.
+ * Frozen/sticky-left columns keep working for free because the clone preserves the
+ * real header cells' classes/inline styles inside its own horizontal scroll context.
+ *
+ * Desktop (enabled=false) is a complete no-op: no clone, no observers, no listeners.
+ */
+export interface UseStickyHeaderCloneArgs {
+    /** Enable only on mobile (e.g. useMobileViewport().isMobile && tableViewIsActive). */
+    enabled: boolean;
+    /** Empty div rendered as the FIRST child of the table card, before the scroll container. */
+    overlayRef: React.RefObject<HTMLDivElement | null>;
+    /** Change this to force a full re-clone (columns identity / language / header font / view). */
+    cloneKey?: unknown;
+    /** CSS var consumed as the pin offset. Defaults to the FilterPanel height var. */
+    offsetVar?: string;
+}
+export declare function useStickyHeaderClone({ enabled, overlayRef, cloneKey, offsetVar, }: UseStickyHeaderCloneArgs): void;

package/dist/components/internal/workbench/components/renderers/tabVariantStyles.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Tab variant definitions for the Tabs renderer.
+ *
+ * Each variant is the source of truth for both the runtime Tabs renderer
+ * (`TabsRenderer.tsx`) and the property-editor preview cards
+ * (`TabsPropertyEditor.tsx`). Every Tailwind utility referenced here is
+ * written as a complete string literal so the JIT content scanner picks
+ * them up and ships them in the final CSS bundle.
+ *
+ * Seven variants, intentionally visually distinct so they can be told apart
+ * at a glance (card/editable-card share the rail but differ in triggers;
+ * vertical-line intentionally reuses `line` for horizontal orientation):
+ *   - `line`:           underline-style tabs (no pill background)
+ *   - `card`:           segmented-pill tabs (single, immutable tab strip)
+ *   - `editable-card`:  segmented-pill tabs with per-tab × close button
+ *                       and a trailing "+ Add" button for adding tabs
+ *   - `pill`:           each tab is its own floating rounded pill,
+ *                       no shared container
+ *   - `boxed`:          tabs sit on top of a bordered container; the
+ *                       active tab "punches through" the bottom border
+ *                       so the tab appears connected to the panel below
+ *   - `segmented`:      full-width iOS-style segmented control — grey
+ *                       rounded rail, equal-width segments, active
+ *                       segment lifts to a white card with indigo text
+ *   - `vertical-line`:  underline-style for top/bottom tabPosition,
+ *                       flips to a left vertical line for left/right
+ *                       tabPosition so vertical tab strips no longer
+ *                       look like a misplaced horizontal underline
+ */
+export type TabVariant = 'line' | 'card' | 'editable-card' | 'pill' | 'boxed' | 'segmented' | 'vertical-line';
+export type TabOrientation = 'horizontal' | 'vertical';
+export declare const DEFAULT_TAB_VARIANT: TabVariant;
+export declare const TAB_VARIANTS: ReadonlyArray<TabVariant>;
+export interface TabVariantClasses {
+    /** Class string applied to the TabsList container. */
+    list: string;
+    /**
+     * Class string applied to each TabsTrigger. Variant-specific active-state
+     * styling is folded in via `data-[state=active]:*` selectors so consumers
+     * don't need to switch classes when active state changes.
+     */
+    trigger: string;
+    /** Class string for the × close button rendered on editable-card tabs. */
+    closableButton: string;
+    /** Class string for the trailing "+ Add" button on editable-card tabs. */
+    addButton: string;
+}
+export declare function normalizeTabVariant(type?: string | null): TabVariant;
+export declare function resolveTabVariantClasses(type?: string | null, orientation?: TabOrientation): TabVariantClasses;
+export declare function isEditableTabVariant(type?: string | null): boolean;

package/dist/components/internal/workbench/components/renderers/tableFilterPanelGridClass.d.ts

@@ -0,0 +1,15 @@
+import { FilterPanelGridColumnCount, FilterPanelGridColumns } from '../../types/renderers';
+
+/**
+ * Merges saved props with layout defaults: base=1, md=3 (legacy TableRenderer behavior).
+ * Optional `sm` / `lg` / `xl` are only applied when set.
+ */
+export declare function mergeFilterPanelGridColumns(cols?: FilterPanelGridColumns): {
+    base: FilterPanelGridColumnCount;
+    sm: FilterPanelGridColumnCount;
+    md: FilterPanelGridColumnCount;
+    lg: FilterPanelGridColumnCount;
+    xl: FilterPanelGridColumnCount;
+};
+/** Full Tailwind class list for the filter field grid. */
+export declare function getFilterPanelGridClassName(cols?: FilterPanelGridColumns, narrowFlow?: boolean): string;

package/dist/components/internal/workbench/components/renderers/tabsItemMapping.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { VisibleWhen } from '../../utils/visibleWhen';
+import { Grid24LayoutConfig } from '../../types/components';
+
+/** Tab item shape stored on Tabs component props.items */
+export interface TabsConfigItem {
+    key: string;
+    label: unknown;
+    visibleWhen?: VisibleWhen;
+    icon?: string;
+    disabled?: boolean;
+    closable?: boolean;
+    badge?: string | number;
+    children?: ReactNode;
+    component?: unknown;
+    components?: unknown[];
+    render?: () => ReactNode;
+    componentConfig?: {
+        type: 'single' | 'multiple';
+        data?: unknown;
+        props?: Record<string, unknown>;
+    };
+    layout?: Grid24LayoutConfig;
+}
+/** Pass through tab item fields needed at runtime (avoid dropping visibleWhen, icon, etc.). */
+export declare function mapTabsConfigItemsForRenderer(items: TabsConfigItem[]): TabsConfigItem[];