@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/renderers/filter-panel/FilterPanelRenderer.d.ts

@@ -0,0 +1,275 @@
+import { default as React } from 'react';
+import { DateRangeQuickSelectPresetKey } from '../../utils/filterPanelDateRangeUtils';
+import { BilingualText } from '../../utils/workbenchDisplayLocale';
+
+export declare function buildStoreMirrorMap(filters: FilterConfig[]): Record<string, string>;
+/** Value keys owned by filters with the given effectScope (a filterSheet contributes every section key). */
+export declare function collectEffectScopeKeys(filters: FilterConfig[], scope: 'partition' | 'page'): string[];
+export declare function parseBusValue(v: unknown, isArray: boolean): string[] | string | unknown;
+/** Test-only: module-level stores otherwise leak committed state across test cases. */
+export declare function __resetFilterPanelSharedState(): void;
+export declare function computePartitionRestore(store: Map<string, Record<string, unknown>>, scopeId: string, scopedKeys: string[], prevValues: Record<string, any>, fromValue: unknown, toValue: unknown, defaults: Record<string, any>): Record<string, any>;
+export declare function expandStoreMirror(patch: Record<string, any>, map: Record<string, string>): Record<string, any>;
+export interface FilterOption {
+    label: string;
+    value: string;
+}
+export interface FilterSheetOptionSource {
+    datasourceId?: string;
+    datasetId?: string;
+    /** Pin a datasource version; omit to use the default version */
+    version?: number;
+    labelKey?: string;
+    valueKey?: string;
+    scope?: string;
+    bindGlobalDateRange?: boolean;
+}
+export interface FilterSheetChipTab {
+    key: string;
+    label: any;
+    dataSource?: FilterSheetOptionSource;
+    options?: FilterOption[];
+    searchable?: boolean;
+}
+export interface FilterSheetSection {
+    key: string;
+    title: any;
+    kind: 'chipMultiSelect' | 'tabbedChip' | 'layeredStore' | 'textInputs';
+    dataSource?: FilterSheetOptionSource;
+    options?: FilterOption[];
+    searchable?: boolean;
+    tabs?: FilterSheetChipTab[];
+    tags?: {
+        key: string;
+        label?: any;
+        dataSource?: FilterSheetOptionSource;
+        options?: FilterOption[];
+    };
+    inputs?: Array<{
+        key: string;
+        placeholder?: any;
+    }>;
+}
+export interface DateCustomTabSource {
+    datasourceId?: string;
+    datasetId?: string;
+    /** Pin a datasource version; omit to use the default version */
+    version?: number;
+    valueKey?: string;
+    labelKey?: string;
+    labelI18nKey?: string;
+    startKey?: string;
+    endKey?: string;
+    subLabelKey?: string;
+    groupKey?: string;
+    groupValue?: string;
+    scope?: string;
+}
+export interface DateCustomTab {
+    key: string;
+    label: any;
+    kind?: 'chips' | 'dateInput';
+    cols?: number;
+    select?: 'multi' | 'single';
+    source?: DateCustomTabSource;
+}
+export interface FilterConfig {
+    key: string;
+    type: 'select' | 'radio' | 'dateRange' | 'text' | 'number' | 'tagInput' | 'segmented' | 'presetDateRange' | 'pillSelect' | 'filterSheet';
+    label: string;
+    options?: FilterOption[];
+    dataSource?: {
+        datasetId?: string;
+        datasourceId?: string;
+        /** Pin a datasource version; omit to use the default version */
+        version?: number;
+        valueField?: string;
+        labelField?: string;
+        scope?: string;
+        bindGlobalDateRange?: boolean;
+    };
+    labelKey?: string;
+    valueKey?: string;
+    multiple?: boolean;
+    defaultValue?: any;
+    useFirstOptionAsDefault?: boolean;
+    /** pillSelect: show a search input in the popover/sheet to fuzzy-filter options. */
+    searchable?: boolean;
+    /** pillSelect (multiple): render a chips bar of selected items below the trigger / in the panel. Default true when multiple.
+     *  filterSheet: also surface every committed dimension as removable chips in the shared bar (default ON; set false to hide). */
+    showSelectedChips?: boolean;
+    /** pillSelect (multiple): forbid clearing to zero — keep at least one selected (falls back to first option). */
+    keepAtLeastOne?: boolean;
+    /** pillSelect (multiple): publish the number of DISTINCT option-row `groupCountField` values
+     *  across the selected options as a numeric page param `{componentId}_{key}GroupCount`
+     *  (e.g. selected R001 + R001N, both rows main_store_code=R001 → 1). A selected value whose
+     *  option row lacks the field counts as its own group. Emitted once the option list is ready
+     *  and on every selection change; empty selection emits 0. */
+    groupCountField?: string;
+    placeholder?: BilingualText;
+    style?: React.CSSProperties;
+    quickSelect?: boolean;
+    quickSelectItems?: Partial<Record<DateRangeQuickSelectPresetKey, boolean>>;
+    useSpecifiedTime?: boolean;
+    showTimePicker?: boolean;
+    specifiedStartTime?: string;
+    specifiedEndTime?: string;
+    displayWidth?: string;
+    dropdownWidth?: string;
+    buttons?: Array<{
+        label: string;
+        value: string;
+    }>;
+    maxTags?: number;
+    segments?: Array<{
+        label: any;
+        value: string;
+        icon?: string;
+    }>;
+    fiscalPresets?: Array<{
+        label: any;
+        value: string;
+    }>;
+    dateRangeSource?: {
+        datasourceId?: string;
+        datasetId?: string;
+        version?: number;
+    };
+    allowCustom?: boolean;
+    presetCols?: number;
+    customSpan?: number;
+    customLabel?: any;
+    customSub?: any;
+    customTabs?: DateCustomTab[];
+    rememberSelection?: boolean;
+    updateTime?: {
+        datasourceId?: string;
+        field: string;
+        text?: unknown;
+        /** Client-side display format with tokens yyyy/MM/dd/HH/mm (e.g. 'HH:mm MM-dd').
+         *  Parsed from the wall-clock string the datasource returns — no timezone math.
+         *  Empty/undefined = render the raw value as-is. */
+        timeFormat?: string;
+        /** Leading icon key from the workbench icon map (e.g. 'clock', 'history',
+         *  'refresh-cw'). Empty/undefined = 'clock'. */
+        icon?: string;
+        /** Label font size in px. Empty/undefined = the default text-xs (12px). */
+        fontSize?: number;
+        /** Built-in refresh interval (seconds): when >0 the label silently refetches on this period
+         *  without remounting FilterPanel; unset/0 = no auto refresh. */
+        refreshInterval?: number;
+        /** When true, the label refetches every time the panel's committed filter values change
+         *  (single-filter commit or filterSheet "Apply"); default false = mount-only fetch plus
+         *  the optional refreshInterval polling, exactly as before. */
+        refreshOnQuery?: boolean;
+    };
+    visibleWhen?: {
+        key: string;
+        value: string | string[];
+    };
+    /** Where this filter's committed value lives:
+     *  'global' (default) — one shared value across partitions AND pages (current behavior).
+     *  'partition' — isolated per partition value (snapshot on leave, restore on return);
+     *                requires the panel `partition` config. Shared across pages.
+     *  'page' — private to the page this panel instance lives on: never published to or
+     *           hydrated from the cross-page store, and not partition-isolated. */
+    effectScope?: 'global' | 'partition' | 'page';
+    sections?: FilterSheetSection[];
+}
+export interface FilterPanelProps {
+    filters: FilterConfig[];
+    presets?: Array<{
+        label: string;
+        value: Record<string, any>;
+    }>;
+    onFilterChange?: (filters: Record<string, any>) => void;
+    className?: string;
+    title?: string;
+    useMockData?: boolean;
+    componentId?: string;
+    pageId?: string;
+    tabId?: string;
+    onParameterChange?: (key: string, value: any) => void;
+    /**
+     * Mobile layout strategy.
+     * - 'stack' (default): each filter on its own row (legacy behavior).
+     * - 'header': segmented/pillSelect/filterSheet flow inline on one wrapping row,
+     *   dateRange/presetDateRange render as a full-width bar on their own row
+     *   (matches the SW prototype global header).
+     */
+    mobileLayout?: 'stack' | 'header';
+    /**
+     * Config-driven filter arrangement. When set, filters are grouped into explicit rows
+     * (overrides mobileLayout/Card single-row). Each row is a horizontal flex group; a
+     * single-filter row spans full width; keys listed in `grow` expand to fill remaining
+     * space; the rest size to content. Filters not in any row are appended in a final row.
+     * Applies on both mobile and desktop.
+     */
+    layout?: {
+        rows: Array<{
+            keys: string[];
+            grow?: string[];
+        }>;
+    };
+    /**
+     * Option caching (docs P0-FilterPanel-cache.md). Filter dimension data changes
+     * infrequently; caching avoids re-querying the DataSource on every Sheet open / tab
+     * switch / page revisit.
+     * - enabled: turn caching on (memory + sessionStorage).
+     * - ttlMs: fallback freshness window when no dataStamp is available.
+     * - stampDatasourceId: lightweight DataSource returning { scope_code, updated_at }.
+     *   When set, a field's cache is invalidated only when its scope's stamp changes.
+     */
+    cache?: {
+        enabled?: boolean;
+        ttlMs?: number;
+        stampDatasourceId?: string;
+    };
+    /**
+     * Pin the panel to the top of the scrolling page area. Normal page flows use
+     * native CSS sticky; edit canvases with short/transformed wrappers fall back
+     * to a fixed portal so the same setting stays reliable in Studio.
+     */
+    sticky?: boolean;
+    /** CSS top offset for sticky mode (use to clear a fixed app header). Default '0px'. */
+    stickyTop?: string;
+    /**
+     * Per-partition isolation for filters marked `effectScope: 'partition'`. `key` names the
+     * filter whose committed value partitions the snapshots (e.g. the hq/store view switcher).
+     * On a partition switch the leaving partition's values are snapshotted and the entering
+     * partition's snapshot (or pristine defaults on first entry) is restored — atomically, in
+     * the same emit batch as the switch itself. Filters without effectScope keep current
+     * global behavior (e.g. the date range persists across views until the user changes it).
+     */
+    partition?: {
+        key: string;
+    };
+    /**
+     * Role-driven filter rules (generic, RBAC-based). When the current user has one of the
+     * configured application `roles` (from GET /applications/:id/users/me/access), the panel:
+     *  - auto-selects ALL loaded options of each filter in `selectAllFilters` (the option lists
+     *    are expected to be already server-filtered per user, so "all" = the user's set);
+     *  - forces each `forceValues[key]` onto that filter;
+     *  - restricts each `restrictOptions[key]` filter's options/segments to the listed values
+     *    (keeps the control but drops the others, e.g. view switch shows only the 'store' segment);
+     *  - hides each filter in `hideFilters`;
+     *  - pins the selected-chips bar of each filter in `pinnedChipsFilters`: the bar shows ALL
+     *    of the filter's options as fixed chips (no ×, no clear-all) and clicking a chip toggles
+     *    its selection in place (unselected chips render muted). For a filterSheet the listed
+     *    key is the store DIMENSION key (a section/tab key, e.g. `storeIds`); listing a mirrored
+     *    pillSelect key covers its sheet partner automatically.
+     * Used e.g. to pin a store manager to the store view of their own stores. No role match (or
+     * not configured) ⇒ the panel behaves exactly as before. Inert unless `roles` is set.
+     */
+    roleFilterRules?: {
+        roles?: string[];
+        selectAllFilters?: string[];
+        hideFilters?: string[];
+        forceValues?: Record<string, string>;
+        restrictOptions?: Record<string, string[]>;
+        pinnedChipsFilters?: string[];
+    };
+}
+export declare function getFilterEmitParamNames(filter: FilterConfig, componentId: string): string[];
+declare const FilterPanelRenderer: React.FC<FilterPanelProps>;
+export default FilterPanelRenderer;

package/dist/components/renderers/filter-panel/filterOptionCache.d.ts

@@ -0,0 +1,33 @@
+export interface FilterOptionCacheEntry {
+    rows: Record<string, unknown>[];
+    dataStamp?: string;
+    cachedAt: number;
+}
+/** cacheKey: filterOpts:{datasourceId}:{version}:{fields}:{scope}:{paramsHash}:{lang}
+ *  datasourceId is globally unique (no workbench namespace needed).
+ *  - scope is part of the entry's identity (it selects the dataStamp that validates the
+ *    entry), so two fields sharing a datasourceId but different scopes must not collide.
+ *  - fields (projected label/value columns) also identifies the rows: two fields can query
+ *    the same datasourceId but project different columns, which must not share an entry. */
+export declare function buildFilterOptionCacheKey(parts: {
+    datasourceId: string;
+    version?: number;
+    fields?: string[];
+    scope?: string;
+    paramsHash?: string;
+    lang: string;
+}): string;
+export declare function getFilterOptionCache(key: string): FilterOptionCacheEntry | null;
+export declare function setFilterOptionCache(key: string, entry: FilterOptionCacheEntry): void;
+/** Decide whether a cache entry is still usable. */
+export declare function isFilterOptionCacheValid(entry: FilterOptionCacheEntry | null, opts: {
+    dataStamp?: string;
+    ttlMs?: number;
+    now?: number;
+}): entry is FilterOptionCacheEntry;
+/** Stable hash for datasource parameters (used in cacheKey for dependsOn / param variants). */
+export declare function hashFilterParams(params: Record<string, unknown> | undefined): string;
+export declare function loadFilterOptions(cacheKey: string, datasourceId: string, outputFields: string[], opts: {
+    dataStamp?: string;
+    ttlMs?: number;
+}, useCache?: boolean, params?: Record<string, unknown>, version?: number): Promise<Record<string, unknown>[]>;

package/dist/components/renderers/filter-panel/filterSelectionMemory.d.ts

@@ -0,0 +1,11 @@
+export interface FilterSelectionMemory {
+    v: string;
+    start?: string;
+    end?: string;
+    tab?: string;
+    savedAt: number;
+}
+export declare const isYmdDateString: (s: unknown) => s is string;
+export declare function buildFilterMemoryKey(workbenchId: string | undefined, componentId: string | undefined, filterKey: string): string;
+export declare function readFilterSelectionMemory(key: string, validPresets: string[]): FilterSelectionMemory | null;
+export declare function writeFilterSelectionMemory(key: string, m: Omit<FilterSelectionMemory, 'savedAt'>): void;

package/dist/components/renderers/filter-panel/index.d.ts

@@ -0,0 +1 @@
+export { default as FilterPanelRenderer } from './FilterPanelRenderer';

package/dist/components/renderers/filter-panel.js

@@ -0,0 +1,5 @@
+import { aK as a } from "./runtime-DX1LfmqO.js";
+export {
+  a as FilterPanelRenderer
+};
+//# sourceMappingURL=filter-panel.js.map

package/dist/components/renderers/filter-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-panel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/form/FileUploadDropzone.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+
+interface FileUploadValue {
+    name: string;
+    size: number;
+    type: string;
+    url: string;
+    fileId: string;
+    status: 'uploaded';
+}
+interface FileUploadDropzoneProps {
+    fieldId: string;
+    value: FileUploadValue | null;
+    isUploading?: {
+        file: File;
+        progress: number;
+    };
+    accept?: Record<string, string[]>;
+    description?: string;
+    onUpload: (fieldId: string, file: File) => void;
+    onRemove: (fieldId: string) => void;
+}
+declare const FileUploadDropzone: React.FC<FileUploadDropzoneProps>;
+export default FileUploadDropzone;

package/dist/components/renderers/form/FormRenderer.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { ParameterConfig } from '../../types';
+import { DatabaseDataSourceConfig } from '../../types/databaseDataSource';
+import { ParameterRecord } from '../../types/parameters';
+import { CustomStylesConfig } from '../../types/components';
+import { EnhancedDataSource } from '../../types/datasource';
+
+interface FormRendererProps {
+    config: any;
+    id?: string;
+    parameterConfig?: ParameterConfig;
+    pageParams?: ParameterRecord;
+    dataSource?: any;
+    datasetConfig?: {
+        datasetId: string;
+        params?: Record<string, any>;
+    };
+    databaseDataSourceConfig?: DatabaseDataSourceConfig;
+    enhancedDataSource?: EnhancedDataSource;
+    useMockData?: boolean;
+    mockData?: Record<string, any>;
+    onParameterChange?: (key: string, value: any) => void;
+    componentId?: string;
+    pageId?: string;
+    tabId?: string;
+    className?: string;
+    customStyles?: CustomStylesConfig;
+}
+declare const FormRenderer: React.FC<FormRendererProps>;
+export default FormRenderer;

package/dist/components/renderers/form/formSizing.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties } from 'react';
+
+export interface FormHeightConfig {
+    height?: number;
+    heightMode?: 'auto' | 'fixed' | 'fullscreen';
+}
+/**
+ * Resolves the form's outer height from exactly one owner.
+ *
+ * Grid24 owns height through rowSpan and always wins while the form is inside
+ * an imposed cell. Standalone forms retain their explicit fixed/fullscreen
+ * behavior for backward compatibility.
+ */
+export declare function resolveFormContainerStyle(config: FormHeightConfig, fillCell: boolean, formTopOffset: number): CSSProperties;

package/dist/components/renderers/form/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FormRenderer } from './FormRenderer';
+export { default as FileUploadDropzone } from './FileUploadDropzone';

package/dist/components/renderers/form.js

@@ -0,0 +1,6 @@
+import { bc as r, bd as a } from "./runtime-DX1LfmqO.js";
+export {
+  r as FileUploadDropzone,
+  a as FormRenderer
+};
+//# sourceMappingURL=form.js.map

package/dist/components/renderers/form.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/hero-card/HeroCardRenderer.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { CustomStylesConfig } from '../../types/components';
+import { DatabaseDataSourceConfig } from '../../types/databaseDataSource';
+import { ComponentParameterConfig } from '../../types/parameters';
+import { HeroCardProps } from './heroCardUtils';
+
+export interface HeroCardRendererProps extends HeroCardProps {
+    id?: string;
+    customStyles?: CustomStylesConfig;
+    useMockData?: boolean;
+    mockData?: Record<string, unknown>[] | Record<string, unknown>;
+    databaseDataSourceConfig?: DatabaseDataSourceConfig | null;
+    componentParameterConfig?: ComponentParameterConfig;
+    pageParams?: Record<string, unknown>;
+    followPageRefresh?: boolean;
+}
+declare const HeroCardRenderer: React.FC<HeroCardRendererProps>;
+export default HeroCardRenderer;

package/dist/components/renderers/hero-card/heroCardRows.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { HeroRow, HeroCardAppearance } from './heroCardUtils';
+
+export interface HeroFontSizes {
+    /** title-bar product/section name */
+    title: number;
+    /** the big metric (hero) number */
+    value: number;
+    /** muted labels, captions, LY, price labels, descriptive text */
+    label: number;
+    /** secondary inline numbers: key-value / kpi / price values, deltas */
+    number: number;
+    /** status / trend badges */
+    badge: number;
+}
+export declare const DEFAULT_HERO_FONT_SIZES: HeroFontSizes;
+interface Ctx {
+    row: Record<string, unknown> | null;
+    ap: HeroCardAppearance;
+    onDark: boolean;
+    currency: unknown;
+    lang: string;
+    fs: HeroFontSizes;
+    /** Narrow-flow layout (mobile / studio phone frame): rows may wrap/truncate.
+        When false the markup must stay byte-identical to the original desktop rendering. */
+    narrow: boolean;
+}
+export declare function renderHeroRow(rowCfg: HeroRow, idx: number, ctx: Ctx): React.ReactNode;
+export declare function renderHeroRows(rows: HeroRow[], ctx: Ctx): React.ReactNode;
+export {};

package/dist/components/renderers/hero-card/heroCardUtils.d.ts

@@ -0,0 +1,164 @@
+export type HeroCardTheme = 'primary' | 'success' | 'info' | 'warning' | 'destructive' | 'muted';
+export type HeroRowFormat = 'raw' | 'number' | 'percent' | 'currency' | 'currency-compact' | 'compact-k' | 'wan';
+export interface HeroKpiItem {
+    label: string;
+    field: string;
+    lyField?: string;
+    diff?: 'absolute' | 'pp' | 'percent';
+    format?: HeroRowFormat;
+    /** Fixed currency for this item's symbol (e.g. 'CNY' for CNY-based stats on a local-currency card); defaults to row.currency. */
+    currency?: string;
+}
+export type HeroRow = {
+    type: 'text';
+    text?: unknown;
+    field?: string;
+    format?: HeroRowFormat;
+    size?: 'xs' | 'sm' | 'base';
+    muted?: boolean;
+} | {
+    type: 'metric';
+    field: string;
+    format?: HeroRowFormat;
+    prefix?: string;
+    suffix?: string;
+    label?: string;
+    lyField?: string;
+    lyLabel?: string;
+    lyFormat?: HeroRowFormat;
+    currency?: string; /** Render LY inline in parens on the same line as the value (e.g. Y3.6K (LY Y323.1K)) instead of below it. */
+    lyInline?: boolean; /** Shrink the row's font sizes so value + inline LY always fit on ONE line (replaces the narrow-flow wrap point). */
+    autoFit?: boolean;
+} | {
+    type: 'trend-badges';
+    items: Array<{
+        label: string;
+        field: string;
+        suffix?: string;
+    }>; /** Shrink the strip's font sizes so all badges stay on ONE line (replaces the narrow-flow flex-wrap). */
+    autoFit?: boolean;
+} | {
+    type: 'key-value';
+    label: string;
+    field: string;
+    format?: HeroRowFormat;
+    prefix?: string;
+    suffix?: string;
+    signedColor?: boolean;
+    signed?: boolean;
+    currency?: string; /** Shrink the row's font sizes so label + value always fit on ONE line. */
+    autoFit?: boolean;
+} | {
+    type: 'dual-key-value';
+    label: unknown;
+    label2: unknown;
+    field: string;
+    field2: string;
+    format?: HeroRowFormat;
+    format2?: HeroRowFormat;
+    currency?: string;
+    signed2?: boolean;
+    signedColor2?: boolean; /** Shrink the row's font sizes so all parts always fit on ONE line. */
+    autoFit?: boolean;
+} | {
+    type: 'progress';
+    field: string;
+    max?: number;
+} | {
+    type: 'kpi-list';
+    columns?: 1 | 2;
+    items: HeroKpiItem[];
+    valueAlign?: 'left' | 'right'; /** Shrink each item row's font sizes so label + value + delta always fit on ONE line. */
+    autoFit?: boolean;
+} | {
+    type: 'title-bar';
+    titleField: string;
+    statusField?: string;
+    statusMap?: Record<string, {
+        label?: unknown;
+        class?: string;
+    }>;
+} | {
+    type: 'price-row';
+    retailLabel?: unknown;
+    retailField: string;
+    sellingLabel?: unknown;
+    sellingField: string;
+    discountField?: string;
+    discountThreshold?: number;
+    discountOff?: boolean;
+    discountLabel?: unknown;
+    discountTextField?: string;
+    currencyField?: string;
+} | {
+    type: 'divider';
+} | {
+    type: 'spacer';
+    size?: number;
+};
+export interface HeroBanner {
+    imageField?: string;
+    colorField?: string;
+    colorMap?: Record<string, string>;
+    emojiField?: string;
+    emojiMap?: Record<string, string>;
+    fallbackColor?: string;
+    fallbackEmoji?: string;
+    height?: number;
+    imageFit?: 'cover' | 'contain';
+    imageBg?: string;
+}
+export declare const HERO_GRADIENT_PRESETS: Record<string, {
+    from: string;
+    to: string;
+}>;
+export interface HeroCardProps {
+    className?: string;
+    rows?: HeroRow[];
+    /** Editor quick preset (on selection, prefer writing concrete gradientFrom/To values directly; lowest priority in the render fallback order). */
+    gradientPreset?: string;
+    /** Static gradient colors (concrete values set explicitly in the page config). */
+    gradientFrom?: string;
+    gradientTo?: string;
+    /** Gradient column bindings: colors read from row data (values supplied by the datasource; highest priority — audit decision §2.4). */
+    gradientFromField?: string;
+    gradientToField?: string;
+    cardWidth?: number | 'full';
+    shell?: 'gradient' | 'muted' | 'detail';
+    banner?: HeroBanner;
+    /** Render ONE card per datasource row (N rows -> N sibling cards) instead of only row[0].
+     *  Each card uses the exact same single-card markup; per-row titles come from row-bound
+     *  rows (e.g. title-bar's titleField). False = original single-card behavior. */
+    cardPerRow?: boolean;
+    titleFontSize?: number;
+    valueFontSize?: number;
+    labelFontSize?: number;
+    numberFontSize?: number;
+    badgeFontSize?: number;
+}
+export declare function formatCompactCurrency(raw: unknown, currency?: unknown): string;
+export declare function formatCompactK(raw: unknown): string;
+export declare function formatCurrencyK(raw: unknown, currency?: unknown): string;
+export declare function formatHeroRowValue(raw: unknown, format?: HeroRowFormat, currency?: unknown, prefix?: string, suffix?: string): string;
+export interface HeroCardAppearance {
+    containerClass: string;
+    containerStyle?: {
+        background?: string;
+    };
+    mutedTextClass: string;
+    strongTextClass: string;
+    badgeClass: string;
+    trendClass: string;
+    progressBarColor: string;
+    progressTrackColor?: string;
+}
+export declare const HERO_DETAIL_APPEARANCE: HeroCardAppearance;
+export declare function normalizeHeroTheme(theme?: string): HeroCardTheme;
+export declare function resolveHeroCardAppearance(props: {
+    theme?: HeroCardTheme | string;
+    gradientFrom?: string;
+    gradientTo?: string;
+}): HeroCardAppearance;
+export declare function readRowField(row: Record<string, unknown> | null | undefined, field?: string): unknown;
+/** Normalize progress when SQL returns 0-100 or 0-1. */
+export declare function normalizeProgressValue(raw: unknown): number;

package/dist/components/renderers/hero-card/index.d.ts

@@ -0,0 +1 @@
+export { default as HeroCardRenderer } from './HeroCardRenderer';

package/dist/components/renderers/hero-card.js

@@ -0,0 +1,5 @@
+import { aL as a } from "./runtime-DX1LfmqO.js";
+export {
+  a as HeroCardRenderer
+};
+//# sourceMappingURL=hero-card.js.map

package/dist/components/renderers/hero-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hero-card.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}