react-semaphor 0.1.532 → 0.1.534

package/dist/types/lib/utils/build-card-export-request.d.ts

@@ -1,30 +0,0 @@
-import { CreateExportRequest, ExportFormattingConfig } from '../api/exports-api.js';
-import { DashboardCardQueryRequestPayloadBase } from '../query-context/build-dashboard-card-query-contract.js';
-import { TCard } from '../types/common-types.js';
-import { DataSource, CardConfig, QueryColumnKeyMap } from '../types/explorer-types.js';
-import { ComparisonMetadataMap } from '../types/query-types.js';
-import { ReportRuntimeContext } from '../../shared/report-runtime-context/index.js';
-import { CanonicalPivotResultTransport } from '../../shared/format-utils/index.js';
-import { SemaphorResultColumn } from '../../shared/analytics-protocol/index.js';
-export type CardExportQueryContext = {
-    connectionId: string;
-    requestPayloadBase: DashboardCardQueryRequestPayloadBase & {
-        cardDataSource: DataSource;
-    };
-};
-export declare function buildCardExportQueryContext(card: TCard, requestPayloadBase: DashboardCardQueryRequestPayloadBase): CardExportQueryContext;
-export declare function buildAsyncCardExportRequest(params: {
-    card: TCard;
-    dashboardId: string;
-    title: string;
-    reportContext: ReportRuntimeContext;
-    totalRows: number;
-    format: 'csv';
-    formatOptions: ExportFormattingConfig;
-    comparisonMetadata?: ComparisonMetadataMap;
-    requestPayloadBase: DashboardCardQueryRequestPayloadBase;
-    resultColumns?: SemaphorResultColumn[];
-    columnKeyMap?: QueryColumnKeyMap;
-    canonicalPivotResult?: CanonicalPivotResultTransport;
-    effectiveCardConfig?: CardConfig;
-}): CreateExportRequest;

package/dist/types/lib/utils/build-saved-editor-card.d.ts

@@ -1,15 +0,0 @@
-import { TCard } from '../types/common-types.js';
-type BuildSavedEditorCardOptions = {
-    isDevMode: boolean;
-    cardSql?: string;
-    isShowingVisual: boolean;
-    selectedSchemaName?: string;
-    selectedDatamodelId?: string;
-    selectedDatabaseName?: string;
-    selectedTableName?: string;
-    selectedConnectionId?: string;
-    remoteChartSettings?: unknown;
-    stripConfig: (config: TCard['config']) => TCard['config'];
-};
-export declare function buildSavedEditorCard(card: TCard, { isDevMode, cardSql, isShowingVisual, selectedSchemaName, selectedDatamodelId, selectedDatabaseName, selectedTableName, selectedConnectionId, remoteChartSettings, stripConfig, }: BuildSavedEditorCardOptions): TCard;
-export {};

package/dist/types/lib/utils/calculate-card-filter-values.d.ts

@@ -1,23 +0,0 @@
-import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-/**
- * Calculates filters and filter values applicable to a specific card,
- * taking into account both sheet-level and card-level scoping.
- *
- * This is a pure function (not a React hook) that can be used in any context,
- * including inside loops and conditionals.
- *
- * Scoping logic:
- * 1. Sheet-level scope is applied first (backward compat sheetId, applyToSheetIds, excludeSheetIds)
- * 2. Card-level scope is applied second (applyToCardIds, excludeCardIds)
- * 3. Filters without scope properties apply to all sheets/cards (default)
- *
- * @param filters - All available filters
- * @param filterValues - All active filter values
- * @param selectedSheetId - ID of the current sheet
- * @param cardId - ID of the card to calculate filters for
- * @returns Object containing cardFilters and cardFilterValues
- */
-export declare function calculateCardFilterValues(filters: TFilter[] | undefined, filterValues: TFilterValue[] | undefined, selectedSheetId: string | null | undefined, cardId: string): {
-    cardFilters: TFilter[] | undefined;
-    cardFilterValues: TFilterValue[] | undefined;
-};

package/dist/types/lib/utils/calculate-context-aware-filters.d.ts

@@ -1,46 +0,0 @@
-import { TCard } from '../types/common-types.js';
-import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-import { InteractionContextMode, TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
-export type ContextMode = InteractionContextMode | undefined;
-export type CalculateContextAwareFiltersParams = {
-    card: TCard;
-    /**
-     * The carried contexts this card resolves under: the top navigation entry's
-     * on its destination dashboard, or an insight's own runtime. Required so
-     * that every caller decides.
-     */
-    transientContexts: readonly TransientInputContext[] | undefined;
-    filters: TFilter[] | undefined;
-    filterValues: TFilterValue[] | undefined;
-    selectedSheetId: string | null | undefined;
-};
-export type CalculateContextAwareFiltersResult = {
-    cardFilters: TFilter[] | undefined;
-    cardFilterValues: TFilterValue[] | undefined;
-    shouldApplyDashboardFilters: boolean;
-    contextMode: ContextMode;
-};
-export type ContextAwareFilterPolicy = Pick<CalculateContextAwareFiltersResult, 'shouldApplyDashboardFilters' | 'contextMode'>;
-/**
- * Whether the dashboard's own toolbar filters apply next to what was carried.
- *
- * | Mode                 | Own toolbar filters apply |
- * |----------------------|---------------------------|
- * | none carried         | yes                       |
- * | `full`               | yes                       |
- * | `interactionFilters` | no                        |
- * | `none`               | no                        |
- */
-export declare function resolveContextAwareFilterPolicy(transientContexts: readonly TransientInputContext[] | undefined): ContextAwareFilterPolicy;
-/**
- * Calculates context-aware filters for a card, taking into account:
- * - The context mode of the carried contexts the card resolves under
- * - Sheet and card-level filter scoping
- *
- * This is a pure function (not a React hook) that can be used in any context,
- * including inside loops, conditionals, and useMemo.
- *
- * @param params - Object containing all required parameters
- * @returns Object containing filter information and context mode
- */
-export declare function calculateContextAwareFilters({ card, transientContexts, filters, filterValues, selectedSheetId, }: CalculateContextAwareFiltersParams): CalculateContextAwareFiltersResult;

package/dist/types/lib/utils/calculated-date-dimension-defaults.d.ts

@@ -1,9 +0,0 @@
-import { GroupByField } from '../types/explorer-types.js';
-export declare const DEFAULT_CALCULATED_DATE_FORMAT: {
-    type: "temporal_bucket";
-    presentation: {
-        mode: "pattern";
-        pattern: string;
-    };
-};
-export declare function withCalculatedDateDimensionDefaults<TField extends GroupByField>(field: TField): TField;

package/dist/types/lib/utils/calculated-dimension-utils.d.ts

@@ -1,2 +0,0 @@
-import { DataType, Field, GroupByField, MetricField } from '../types/explorer-types.js';
-export declare function createCalculatedDimension(name: string, expression: string, inputFields: Array<Field | GroupByField | MetricField>, dataType: DataType, cardId: string, existingId?: string): GroupByField;

package/dist/types/lib/utils/calculated-field-identity-utils.d.ts

@@ -1,20 +0,0 @@
-import { Field } from '../types/explorer-types.js';
-export { getCalculatedFieldNamespace, getStableDomainCalculatedFieldId } from '../../shared/dashboard-authoring/calculated-field-identity.js';
-export declare function normalizeCalculatedFieldId(id?: string): string | undefined;
-export declare function getCalculatedFieldExpression(field: Field): string | undefined;
-export declare function getCalculatedFieldComparableKey(field: Field): string;
-export declare function getCalculatedFieldIdentityKey(field: Field): string;
-export declare function matchesCalculatedField(existing: Field, candidate: Field, options?: {
-    allowComparableFallback?: boolean;
-}): boolean;
-export declare function findCalculatedFieldIndex<TField extends Field>(fields: TField[], field: Field, options?: {
-    allowComparableFallback?: boolean;
-}): number;
-export declare function dedupeCalculatedFields<TField extends Field>(fields: TField[]): TField[];
-export declare function upsertCalculatedField<TField extends Field>(fields: TField[], field: TField, matchField?: Field, options?: {
-    allowComparableFallback?: boolean;
-}): TField[];
-export declare function removeCalculatedField<TField extends Field>(fields: TField[], field: Field, options?: {
-    allowComparableFallback?: boolean;
-}): TField[];
-export declare function buildCalculatedFieldComparableKeySet(fields: Field[]): Set<string>;

package/dist/types/lib/utils/calculated-field-normalization.d.ts

@@ -1,2 +0,0 @@
-export declare const normalizeCalculatedName: (value: string) => string;
-export declare const normalizeFieldId: (id?: string) => string | undefined;

package/dist/types/lib/utils/calculated-field-operations.d.ts

@@ -1,40 +0,0 @@
-import { CalculatedFieldOperation } from '../types/explorer-types.js';
-/**
- * Operation metadata for UI display
- */
-export interface OperationDefinition {
-    id: CalculatedFieldOperation;
-    label: string;
-    symbol: string;
-    description: string;
-    template?: () => string;
-    /**
-     * Insert template for the Variant B "Templates" menu — uses
-     * named placeholders `{a}` / `{b}` that the user replaces with real
-     * field tokens after insertion. Templates deliberately do not wrap
-     * placeholders in aggregate functions because `{a}` / `{b}` may be replaced
-     * with existing calculated metrics that are already aggregate-context.
-     * This is intentionally separate from
-     * `template` (which uses positional `{field_0}` / `{field_1}` tokens
-     * for the legacy preset-operation save path).
-     */
-    insertTemplate?: () => string;
-    /** Short, human-readable description of the formula shape. */
-    insertHint?: string;
-    requiresTwoInputs: boolean;
-    allowsCustomExpression?: boolean;
-}
-export declare const OPERATIONS: OperationDefinition[];
-/**
- * Templates exposed in the Variant B "Templates" menu — every operation
- * except `custom`. Order matches OPERATIONS for stable display.
- */
-export declare const FORMULA_TEMPLATES: OperationDefinition[];
-/**
- * Implementation Notes:
- * - ALL operations now use tokens ({field_0}, {field_1}, etc.) instead of bare column names
- * - Template functions no longer take (a, b) parameters - they return static token patterns
- * - Custom expressions will use drag-and-drop field builder (creates tokens automatically)
- * - No bare column names anywhere in the system
- * - Backend replaces tokens with qualified column names (e.g., t0.sales)
- */

package/dist/types/lib/utils/calculated-field-permissions.d.ts

@@ -1,12 +0,0 @@
-export type CalculatedFieldAuthoringUserContext = {
-    type: 'organization' | 'tenant';
-    permissions?: {
-        canEdit?: boolean;
-    } | null;
-};
-/**
- * Local calculated fields follow dashboard edit access. Organization users
- * retain the existing authoring behavior; tenant users must have an explicit
- * edit permission so viewer tokens fail closed.
- */
-export declare function canEditLocalCalculatedFields(userContext: CalculatedFieldAuthoringUserContext | null | undefined): boolean;

package/dist/types/lib/utils/calculated-field-row-templates.d.ts

@@ -1,15 +0,0 @@
-import { CalculatedFieldTemplateId } from '../types/calculated-field-template-types.js';
-export declare const ROW_TEMPLATE_CATEGORIES: readonly ["Logic", "Text", "Dates", "Numbers", "Empty values"];
-export type RowTemplateCategory = (typeof ROW_TEMPLATE_CATEGORIES)[number];
-export type RowFormulaTemplateDefinition = {
-    id: CalculatedFieldTemplateId;
-    label: string;
-    symbol: string;
-    preview: string;
-    hint: string;
-    category: RowTemplateCategory;
-    keywords: string[];
-    common?: boolean;
-};
-/** Dialect-neutral searchable metadata. Executable SQL remains app-owned. */
-export declare const ROW_FORMULA_TEMPLATES: RowFormulaTemplateDefinition[];

package/dist/types/lib/utils/calculated-field-scope-utils.d.ts

@@ -1,20 +0,0 @@
-import { TDashboard, TSheet } from '../types/common-types.js';
-import { Field, FieldScope } from '../types/explorer-types.js';
-import { normalizeCalculatedFieldId } from './calculated-field-identity-utils.js';
-export declare function hasSheetCalculatedFieldStore(sheet: TSheet | null | undefined): boolean;
-export { normalizeCalculatedFieldId };
-export declare function mergeCalculatedFields(...fieldGroups: Array<Field[] | undefined>): Field[];
-export declare function getPersistedDashboardCalculatedFieldsForSave(draftFields: Field[] | undefined): Field[] | undefined;
-export declare function hardMigrateDashboardCalculatedFields(dashboard: TDashboard): TDashboard;
-export declare function getLegacySheetCalculatedFields(sheet: TSheet | null | undefined, selectedFrameId?: string | null): Field[];
-export declare function getSheetCalculatedFields(sheet: TSheet | null | undefined, _selectedFrameId?: string | null): Field[];
-export declare function getEditableSheetCalculatedFields(sheet: TSheet | null | undefined, selectedFrameId?: string | null): Field[];
-export declare function getPersistedSheetCalculatedFieldsForSave(draftFields: Field[] | undefined): Field[] | undefined;
-export declare function resolveLocalCalculatedFieldScope(args: {
-    field: Field;
-    sheetFields?: Field[];
-    dashboardFields?: Field[];
-}): {
-    scope: Exclude<FieldScope, 'domain'>;
-    matchedField?: Field;
-};

package/dist/types/lib/utils/calculated-field-token-utils.d.ts

@@ -1,34 +0,0 @@
-import { AvailableField } from '../hooks/calculated-fields/use-available-fields.js';
-export declare function normalizeToken(token: string): string;
-export declare function extractExpressionTokens(expression: string): string[];
-export declare function getUniqueTokens(tokens: string[]): string[];
-export declare function buildTokenCandidates(fields: AvailableField[]): Map<string, AvailableField[]>;
-export type ExpressionTokenRange = {
-    /** Text between the braces, as typed. */
-    token: string;
-    /** Offset of `{`. */
-    start: number;
-    /** Offset just past `}`. */
-    end: number;
-};
-/** Every `{token}` in the expression with its offsets. Same grammar as
- * `extractExpressionTokens`, so it agrees with validation. */
-export declare function findExpressionTokenRanges(expression: string): ExpressionTokenRange[];
-/** Template slots are single lowercase letters: `{a}`, `{b}`. */
-export declare function isTemplatePlaceholderToken(token: string): boolean;
-/** A token binds only when exactly one field claims it, the same rule
- * `resolveExpressionTokens` uses before validation. */
-export declare function isResolvedToken(token: string, candidates: Map<string, AvailableField[]>): boolean;
-/**
- * Tokens that do not bind to a field, in the order the author should fill
- * them: template placeholders by letter (`{a}` before `{b}`, even when the
- * dialect SQL mentions `{b}` first), then any other unbound token (typo,
- * stale or ambiguous reference) by position.
- */
-export declare function findPendingTokenRanges(ranges: ExpressionTokenRange[], candidates: Map<string, AvailableField[]>): ExpressionTokenRange[];
-export declare function resolveExpressionTokens(expression: string, fields: AvailableField[]): {
-    orderedTokens: string[];
-    orderedFields: (AvailableField | null)[];
-    unresolvedTokens: string[];
-};
-export declare function replaceTokensWithIndexes(expression: string, orderedTokens: string[]): string;

package/dist/types/lib/utils/calculated-field-transition-utils.d.ts

@@ -1,113 +0,0 @@
-import { CardConfig, Field, FieldScope } from '../types/explorer-types.js';
-import { TCard, TFrame } from '../types/common-types.js';
-import { TFilter } from '../../components/surfboard/filter/types.js';
-type CalculatedFieldScope = FieldScope;
-type CommitSharedCalculatedFieldsArgs = {
-    nextSharedFields: Field[];
-    currentSharedFields?: Field[];
-    isVisualEditing: boolean;
-    selectedSheetId?: string | null;
-    updateFrame: (patch: Partial<TFrame>) => void;
-    updateSheetCalculatedFields?: (sheetId: string, calculatedFields: Field[]) => void;
-    queueFramesForVisualEdit?: (sheetId: string, frames: TFrame[]) => void;
-    currentFrame?: TFrame;
-    nextFramePatch?: Partial<TFrame>;
-    persistFrame?: (sheetId: string, frame: TFrame) => void;
-    persistFrames?: TFrame[];
-};
-type BuildPromotedCalculatedFieldStateArgs<TField extends Field> = {
-    card: TCard;
-    frame?: TFrame;
-    sheetFrames?: TFrame[];
-    dashboardFilters?: TFilter[];
-    activeFields: TField[];
-    storedFields: Field[];
-    sharedFields: Field[];
-    promotedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-};
-/** Reconcile selections independently of the edited definition's authored role. */
-export declare function reconcileCalculatedFieldSelections(config: CardConfig | undefined, previous: Field, updated: Field, options?: {
-    allowLegacyComparableFallback?: boolean;
-}): Partial<CardConfig>;
-export declare function saveCalculatedFieldToCardScope<TField extends Field>(args: {
-    cardConfig?: CardConfig;
-    storedFields: Field[];
-    sharedFields: Field[];
-    updatedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-}): {
-    nextStoredFields: Field[];
-    nextSharedFields: Field[];
-    cardConfigPatch: Partial<CardConfig>;
-};
-export declare function saveCalculatedFieldToSheetScope<TField extends Field>(args: {
-    cardConfig?: CardConfig;
-    storedFields: Field[];
-    sheetFields: Field[];
-    dashboardFields?: Field[];
-    updatedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-}): {
-    nextStoredFields: Field[];
-    nextSheetFields: Field[];
-    nextDashboardFields: Field[] | undefined;
-    cardConfigPatch: Partial<CardConfig>;
-};
-export declare function saveCalculatedFieldToSharedScope<TField extends Field>(args: {
-    cardConfig?: CardConfig;
-    storedFields: Field[];
-    sharedFields: Field[];
-    sheetFields?: Field[];
-    updatedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-}): {
-    nextStoredFields: Field[];
-    nextSharedFields: Field[];
-    nextSheetFields: Field[] | undefined;
-    cardConfigPatch: Partial<CardConfig>;
-};
-/** Domain promotion establishes a new catalog identity, unlike local saves.
- * Preserve its narrower dashboard-only comparison fallback; routing it through
- * the local scope-pair policy would also enable sheet comparison matching. */
-export declare function promoteCalculatedFieldToDomainScope<TField extends Field>(args: {
-    activeFields: TField[];
-    storedFields: Field[];
-    sharedFields: Field[];
-    promotedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-}): {
-    nextActiveFields: TField[] | null;
-    nextStoredFields: Field[];
-    nextSharedFields: Field[];
-};
-export declare function resolvePromotedDomainField<TField extends Field>(args: {
-    field: TField;
-    name: string;
-    label: string;
-    description?: string;
-    datasetName?: string;
-    qualifiedDatasetName?: string;
-}): TField;
-export declare function rewritePromotedCalculatedFieldAcrossCards<TField extends Field>(args: {
-    cards: TCard[];
-    promotedField: TField;
-    editingField?: Field;
-    previousScope: CalculatedFieldScope;
-}): TCard[];
-export declare function buildPromotedCalculatedFieldState<TField extends Field>(args: BuildPromotedCalculatedFieldStateArgs<TField>): {
-    nextActiveFields: TField[] | null;
-    nextStoredFields: Field[];
-    nextSharedFields: Field[];
-    nextFrameCards: TCard[] | undefined;
-    nextSheetFrames: TFrame[] | undefined;
-    nextCurrentCard: TCard | undefined;
-    nextDashboardFilters: TFilter[] | undefined;
-};
-export declare function commitSharedCalculatedFields(args: CommitSharedCalculatedFieldsArgs): void;
-export {};

package/dist/types/lib/utils/calculated-field-utils.d.ts

@@ -1,37 +0,0 @@
-import { MetricField, CalculatedFieldOperation, CalculatedFieldFormula } from '../types/explorer-types.js';
-export declare function addExplicitAggregatesToExpression(expression: string, inputFields: MetricField[]): string;
-/**
- * Creates a new calculated field from user inputs
- * IMPORTANT: Both expression and calculatedFormula are generated atomically
- * from the same inputs, preventing drift.
- */
-export declare function createCalculatedField(name: string, operation: CalculatedFieldOperation, metricA: MetricField | null, metricB: MetricField | null, _formatConfig: {
-    format: string;
-    decimalPlaces: number;
-}, // Reserved for future use
-cardId: string, existingId?: string, customExpression?: string, // For custom operations
-constantFactor?: number, // For scale operation
-customInputFields?: MetricField[]): MetricField;
-/**
- * NOTE: getFieldReference() function removed
- * We now use tokens ({field_0}, {field_1}, etc.) instead of field references.
- * The backend will replace tokens with qualified column names.
- */
-/**
- * Validates a calculated field for circular dependencies
- * IMPORTANT: Only validates standard operations; skips custom expressions
- */
-export declare function validateCalculatedField(field: MetricField, allMetrics: MetricField[]): {
-    valid: boolean;
-    error?: string;
-};
-/**
- * Gets all dependencies of a calculated field (for display/debugging)
- */
-export declare function getCalculatedFieldDependencies(field: MetricField, allMetrics: MetricField[]): MetricField[];
-/**
- * Formats the display formula for UI
- * Since we removed displayFormula from the type, this function now generates
- * a human-readable formula from the operation and input fields.
- */
-export declare function formatDisplayFormula(formula: CalculatedFieldFormula): string;

package/dist/types/lib/utils/card-calculated-field-utils.d.ts

@@ -1,12 +0,0 @@
-import { Field, GroupByField, MetricField } from '../types/explorer-types.js';
-export declare function resolveCardCalculatedFieldForEdit(field: Field, options: {
-    storedCalculatedFields: Field[];
-    metricFields: MetricField[];
-    groupByFields: GroupByField[];
-}): MetricField | GroupByField | undefined;
-export declare function resolveDomainCalculatedFieldForEdit(field: Field, availableFields: Field[]): MetricField | GroupByField | undefined;
-export declare function mergeConfiguredCalculatedFieldSelection<TField extends Field>(existingField: TField, nextField: TField): TField;
-export declare function upsertCardCalculatedFieldInConfig<TField extends Field>(fields: TField[], field: TField, matchField?: Field, options?: {
-    allowComparableFallback?: boolean;
-    mergeMatchedField?: (existing: TField, next: TField) => TField;
-}): TField[] | null;

package/dist/types/lib/utils/card-config-utils.d.ts

@@ -1,24 +0,0 @@
-import { CardConfig, DataSource, FilterGroup, JoinPlan } from '../types/explorer-types.js';
-import { TCard } from '../types/common-types.js';
-/** Matrix acquisition requires its structured definition, never an authored SQL query. */
-export declare function supportsSqlEditor(cardType: TCard['type']): boolean;
-/** Crossing this representation boundary starts a fresh query, not an implicit migration. */
-export declare function resetMatrixRepresentation(card: TCard, nextType: TCard['type']): Partial<TCard>;
-/** Replacing the base dataset starts a new definition; metadata refresh does not. */
-export declare function withAuthoredCardDataSource(card: TCard, dataSource: DataSource): Partial<TCard>;
-export declare function getAuthoredCardJoinPlan(card: Pick<TCard, 'type' | 'config'>): JoinPlan | undefined;
-/** The normal join editor writes the canonical definition, including empty drafts. */
-export declare function withAuthoredCardJoinPlan(card: Pick<TCard, 'type' | 'config' | 'dataSource'>, joinPlan: JoinPlan | undefined): CardConfig;
-/** Authored predicates from the card's canonical representation. */
-export declare function getAuthoredCardFilters(card: Pick<TCard, 'type' | 'config'> | undefined): FilterGroup | undefined;
-export declare function withAuthoredCardFilters(card: Pick<TCard, 'type' | 'config' | 'dataSource'>, filters: FilterGroup | undefined): CardConfig;
-/**
- * Checks if a card config object has actual configuration data
- * An empty config object {} should be treated as no config
- */
-export declare function hasValidCardConfig(config: CardConfig | undefined, cardType?: TCard['type']): boolean;
-type CardSetupCheckOptions = {
-    skipSetupCheck?: boolean;
-};
-export declare function isCardUnconfigured(card: Pick<TCard, 'type' | 'sql' | 'config' | 'connectionId' | 'dataSource' | 'customCardPreferences'>, options?: CardSetupCheckOptions): boolean;
-export {};

package/dist/types/lib/utils/card-loading-state.d.ts

@@ -1,18 +0,0 @@
-import { TCard } from '../types/common-types.js';
-type CardLoadingPresentationInput = {
-    card: Pick<TCard, 'type'> | undefined;
-    fetchStatus?: 'fetching' | 'paused' | 'idle';
-    isLoading?: boolean;
-    isFetching?: boolean;
-    isPending?: boolean;
-    hasRecords?: boolean;
-};
-export declare function shouldUseCardSkeletonDuringRefetch(card: Pick<TCard, 'type'> | undefined): boolean;
-export declare function showsOwnRefetchCue(card: Pick<TCard, 'type'> | undefined): boolean;
-export declare function getCardLoadingPresentation({ card, fetchStatus, isLoading, isFetching, isPending, hasRecords, }: CardLoadingPresentationInput): {
-    isBusy: boolean;
-    showCardSkeleton: boolean;
-    showGenericLoadingFallback: boolean;
-    showStaleDataOverlay: boolean;
-};
-export {};

package/dist/types/lib/utils/card-utils.d.ts

@@ -1,70 +0,0 @@
-import { TDashboard, TCard, TSheet } from '../types/common-types.js';
-export type DashboardCardEntry = {
-    card: TCard;
-    sheet: TSheet;
-    /** Set when the card sits in a frame. */
-    frameId?: string;
-    /** Set when the card belongs to a document section (a section may own several cards). */
-    sectionId?: string;
-};
-/** Dashboard cards: sheet cards and frame cards. Document section cards are not included. */
-export declare function getDashboardCardEntries(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
-/**
- * Every card a dashboard hosts, with where it sits: sheet cards, frame cards,
- * and every card of a document section. Use this, not
- * `getDashboardCardEntries`, when a card may be reached by a scope that names
- * document sections.
- */
-export declare function getDashboardCardLocations(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
-export declare function getDashboardCards(dashboard: Pick<TDashboard, 'sheets'>): TCard[];
-/**
- * Check if a card ID is unique across the entire dashboard
- * @param dashboard - The dashboard to check against
- * @param cardId - The proposed card ID
- * @param currentCardId - The current card ID (to exclude from check when editing)
- * @returns true if the ID is unique, false otherwise
- */
-export declare function isCardIdUnique(dashboard: TDashboard, cardId: string, currentCardId?: string): boolean;
-/**
- * Validate card ID format
- * @param cardId - The card ID to validate
- * @returns An object with isValid flag and error message if invalid
- */
-export declare function validateCardId(cardId: string): {
-    isValid: boolean;
-    error?: string;
-};
-/**
- * Sanitize user input for card ID
- * Converts to lowercase and replaces spaces with hyphens
- * @param input - The user input to sanitize
- * @returns Sanitized card ID
- */
-export declare function sanitizeCardId(input: string): string;
-/**
- * Get all card IDs in the dashboard
- * @param dashboard - The dashboard to extract IDs from
- * @returns Array of all card IDs
- */
-export declare function getAllCardIds(dashboard: TDashboard): string[];
-/**
- * Find a card by ID in the dashboard
- * @param dashboard - The dashboard to search in
- * @param cardId - The card ID to find
- * @returns The card if found, undefined otherwise
- */
-export declare function findCardById(dashboard: TDashboard, cardId: string): TCard | undefined;
-/**
- * A dashboard card (sheet or frame) by id. Document section cards are not
- * included: they need their section for input resolution, so they are found
- * through section-aware lookups (for example the dashboard input snapshot's
- * section targets). Phase 1.2 routes KPI card execution through those.
- */
-export declare function findCardLocationById(dashboard: TDashboard, cardId: string): {
-    card: TCard;
-    sheet: TSheet;
-} | undefined;
-export declare function findFrameCardLocationById(dashboard: TDashboard, cardId: string): {
-    card: TCard;
-    sheet: TSheet;
-} | undefined;

package/dist/types/lib/utils/chart-icon-utils.d.ts

@@ -1,26 +0,0 @@
-import { default as React } from 'react';
-import { BulletChartIcon } from '../../components/icons/bullet-chart-icon.js';
-export declare const chartTypes: ({
-    id: string;
-    icon: React.ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
-    label: string;
-} | {
-    id: string;
-    icon: import('react-icons/lib').IconType;
-    label: string;
-} | {
-    id: string;
-    icon: typeof BulletChartIcon;
-    label: string;
-})[];
-/**
- * Auto-detect chart type from component name
- * Checks if the lowercase name contains any standard chart type IDs
- * Special handling for doughnut/donut spelling variations
- */
-export declare const getAutoDetectedChartIcon: (componentName: string) => React.ReactElement<any> | null;
-/**
- * Get chart icon component by chart type ID
- * Returns the icon component for a specific chart type
- */
-export declare const getChartIconByType: (chartType: string, className?: string) => React.ReactElement<any>;

package/dist/types/lib/utils/chart-type-field-validation.d.ts

@@ -1,25 +0,0 @@
-import { Field, ContainerId } from '../types/explorer-types.js';
-import { TChartType } from '../charts/types.js';
-export interface FieldValidationResult {
-    isValid: boolean;
-    reason?: string;
-}
-/**
- * Validates if a field can be dropped/added to a container for a specific chart type.
- * This centralizes all chart-type-specific field validation logic.
- *
- * @param field - The field to validate
- * @param containerId - The target container (groupBy, metrics, pivotBy, sortBy)
- * @param chartType - The current chart type
- * @returns Validation result with optional reason for rejection
- */
-export declare function validateFieldForChartType(field: Field, containerId: ContainerId, chartType: TChartType): FieldValidationResult;
-/**
- * Checks if a field is compatible with the current chart type
- * This is used for visual feedback (e.g., disabling fields in the field list)
- *
- * @param field - The field to check
- * @param chartType - The current chart type
- * @returns true if the field can be used with this chart type
- */
-export declare function isFieldCompatibleWithChartType(field: Field, chartType: TChartType): boolean;

package/dist/types/lib/utils/comparison-export-utils.d.ts

@@ -1,31 +0,0 @@
-import { TCard } from '../types/common-types.js';
-import { QueryColumnKeyMap } from '../types/explorer-types.js';
-import { ComparisonMetadataMap } from '../types/query-types.js';
-import { ComparisonPresentationSpec } from '../../shared/analytics-protocol/index.js';
-export type ComparisonExportProjection = {
-    excludedKeys: Set<string>;
-    selectedDerivedKeys: Set<string>;
-    columnLabels: Map<string, string>;
-    columnPresentationOwners: Map<string, {
-        metricId: string;
-        metricAlias: string;
-        kind: 'comparison' | 'delta' | 'percent_change' | 'ratio';
-    }>;
-};
-export declare function getComparisonExportProjection(params: {
-    comparisonMetadata?: ComparisonMetadataMap;
-    presentation?: ComparisonPresentationSpec;
-    resolveMetricName?: (identity: {
-        metricId: string;
-        metricAlias: string;
-    }) => string | undefined;
-}): ComparisonExportProjection;
-export declare function getCardComparisonExportProjection(params: {
-    card?: TCard;
-    comparisonMetadata?: ComparisonMetadataMap;
-    columnKeyMap?: QueryColumnKeyMap;
-}): ComparisonExportProjection;
-export declare function hasComparisonExportMetadataGap(params: {
-    card: TCard;
-    comparisonMetadata?: ComparisonMetadataMap;
-}): boolean;