@vizzly/services 0.15.0-dev-dfdff442d54d270df03c337679ae904243a831b6 → 0.15.0-dev-f576f0918251ec7901abbda943caec672e40c29c

package/dist/types/shared-logic/src/CustomView/types.d.ts

@@ -0,0 +1,29 @@
+import { FilterConfig } from '../AdditionalFilter/types';
+import { Component } from '../Component/types';
+export type CustomView = StaticCustomView | SelectableCustomView;
+export type CustomViewCallbackParams = {
+    attributes?: Component.CustomViewAttributes;
+    filterConfig: FilterConfig;
+};
+export type BaseCustomView = {
+    id: string;
+};
+export type StaticCustomView = BaseCustomView & {
+    rowIndex: number;
+    cellIndex: number;
+    Component: (params: CustomViewCallbackParams) => JSX.Element | string;
+    options?: {
+        disableAddCell?: boolean;
+        raw?: boolean;
+    };
+    attributes?: {
+        displayTitle?: string;
+        displaySubject?: string;
+    };
+};
+export type SelectableCustomView = BaseCustomView & {
+    title: string;
+    Icon: () => JSX.Element;
+    Component: (params: CustomViewCallbackParams) => JSX.Element | string;
+};
+export type DumpedCustomViewAttributes = Component.CustomViewAttributes;

package/dist/types/shared-logic/src/Dashboard/Dashboard.d.ts

@@ -0,0 +1,39 @@
+import { Component as ComponentType } from '../Component/types';
+import { DataSet } from '../DataSet/types';
+import { CustomField } from '../CustomField/types';
+import { Dashboard, SaveableDashboardDefinition, ImportableDashboard } from './types';
+import { FieldUsage } from '@vizzly/api-client';
+export * from './saveableDashboardDefinitionSchema';
+export * from './fromRaw';
+export declare const indexOfDataSet: (dashboard: Dashboard, dataSetId: string) => number;
+export declare const getDataSet: (dashboard: Dashboard, dataSetId: string) => DataSet | null;
+export declare const hasDataSet: (dashboard: Dashboard, dataSetId: string) => boolean;
+export declare const getComponentsUsingDataSet: (dashboard: Dashboard, dataSetId: string) => ComponentType[];
+export declare const toSaveableDefinition: (dashboard: Dashboard) => SaveableDashboardDefinition;
+export declare const prepareDashboardForImport: (dashboardToImport: Dashboard | ImportableDashboard) => ImportableDashboard;
+export declare const mergeDashboardInStateAndDashboardToImport: ({ dashboardToImport, dashboardInState, }: {
+    dashboardToImport: ImportableDashboard;
+    dashboardInState: Dashboard;
+}) => Dashboard;
+export declare const setDataSets: (dashboardWithoutDataSets: Omit<Dashboard, "dataSets">, dataSets: DataSet[], customFields: {
+    [dataSetId: string]: CustomField[];
+}) => Dashboard;
+export declare const newSaveable: (overrides: Partial<SaveableDashboardDefinition>) => SaveableDashboardDefinition;
+export declare const takePlaygroundDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const takeLiveDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const getDataSetsUsedOnDisplay: (dashboard: Dashboard) => Array<DataSet>;
+export declare const getDataSetsUsedOnDashboard: (dashboard: Dashboard) => Array<DataSet>;
+export declare const getCopiesOfParentDashboard: (parentDashboardId: string, dashboards: Dashboard[]) => Dashboard[];
+export declare const getParentDashboards: (dashboards: Dashboard[]) => Dashboard[];
+export declare const getFirstCreated: (dashboards: Dashboard[]) => Dashboard;
+export declare const orderByLastUpdated: (dashboards: Dashboard[]) => Dashboard[];
+export declare const takeMostRecentlyUpdated: (dashboards: Dashboard[]) => Dashboard | null;
+export declare const find: (dashboards: Dashboard[], dashboardId: string) => Dashboard | null;
+export declare const updateLibraryWithProtectedComponents: (dashboards: Dashboard[]) => Dashboard[];
+export declare function resetToParentDashboard(dashboard: Dashboard, dashboards: Dashboard[], parentDashboardId: string): Dashboard;
+export declare const buildProgrammaticDashboard: (programaticDashboards: Partial<SaveableDashboardDefinition>[], dataSets: DataSet[]) => Dashboard[];
+export declare const VIZZLY_EDITOR_ID = "vizzly_editor";
+export declare function updateWithProgrammaticDashboard(allDashboards: Dashboard[], programmaticDashboards: Dashboard[]): Dashboard[];
+export declare const addUniqueLibraryComponents: (programmaticLibrary: ComponentType[], dashboardLibrary: ComponentType[]) => ComponentType[];
+export declare const checkAndReturnProgrammaticDashboardId: (dashboards: Dashboard[]) => string | undefined;
+export declare const getFieldUsage: (dashboardDefinition: SaveableDashboardDefinition, dataSets: DataSet[]) => FieldUsage;

package/dist/types/shared-logic/src/Dashboard/fromRaw.d.ts

@@ -0,0 +1,23 @@
+import { StoredTheme } from '../Theme/types';
+import { Dashboard, SaveableDashboardDefinition } from './types';
+import { PartialBy } from '../typeHelpers';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export type RawDefinition = PartialBy<SaveableDashboardDefinition, 'isPlayground' | 'customFields'>;
+export type RawDashboard<Definition = RawDefinition> = {
+    id: string;
+    parent_dashboard_id: string;
+    definition: Definition;
+    name?: string | null;
+    theme: StoredTheme & {
+        rowLimit?: number;
+    };
+    created_at: string;
+    updated_at: string;
+    metadata?: Dashboard.ExternalMetadata;
+    webhook_id: string | null;
+    permission: {
+        scope: 'read' | 'read_write';
+        token: string;
+    };
+};
+export declare const fromRaw: (rawDashboard: RawDashboard, queryEngineConfig: QueryEngineConfig | undefined) => Omit<Dashboard, "dataSets">;

package/dist/types/shared-logic/src/Dashboard/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Dashboard';
+export * from './types';

package/dist/types/shared-logic/src/Dashboard/saveableDashboardDefinitionSchema.d.ts

@@ -0,0 +1,5 @@
+import Joi from '@vizzly/joi';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare const colSpanSchema: Joi.NumberSchema<number>;
+export declare const saveableDashboardDefinitionSchema: (queryEngineConfig: QueryEngineConfig) => Joi.ObjectSchema<any>;
+export declare function displaySchema(queryEngineConfig: QueryEngineConfig): Joi.ArraySchema<any[]>;

package/dist/types/shared-logic/src/Dashboard/types.d.ts

@@ -0,0 +1,50 @@
+import { AdditionalFilter } from '../AdditionalFilter/types';
+import { Component } from '../Component/types';
+import { DataSet } from '../DataSet/types';
+import { CustomField } from '../CustomField/types';
+import { Display, DisplayDumped } from '../Display/types';
+import { StoredTheme } from '../Theme/types';
+export type WebParentDashboard = Pick<Dashboard, 'id' | 'webhookId' | 'createdAt' | 'updatedAt'>;
+export declare namespace Dashboard {
+    type ExternalMetadata = {
+        [key: string]: string | number;
+    };
+}
+export type Dashboard = {
+    id: string;
+    name?: string | null;
+    parentDashboardId: string | null;
+    metadata: Dashboard.ExternalMetadata;
+    /**
+     * @deprecated
+     */
+    theme: StoredTheme;
+    display: Display;
+    webhookId: string | null;
+    componentLibrary: Component[];
+    dataSets: DataSet[];
+    globalFilters: AdditionalFilter[];
+    /** @deprecated */
+    isPlayground: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    /** @deprecated */
+    protectedByOrganisation?: boolean;
+    isProgrammatic?: boolean;
+    permission?: {
+        scope: 'read' | 'read_write';
+        token: string;
+    };
+};
+export type SaveableDashboardDefinition = {
+    display: DisplayDumped;
+    componentLibrary: Component.RawComponent[];
+    globalFilters: Array<AdditionalFilter>;
+    isPlayground: boolean;
+    customFields: {
+        [dataSetId: string]: Array<CustomField>;
+    };
+    project_id?: string;
+    id?: string;
+};
+export type ImportableDashboard = Omit<Dashboard, 'id' | 'parentDashboardId' | 'webhookId' | 'createdAt' | 'updatedAt' | 'isProgrammatic' | 'theme' | 'data' | 'permission' | 'protectedByOrganisation' | 'isPlayground'>;

package/dist/types/shared-logic/src/DataPanelConfig/types.d.ts

@@ -0,0 +1,45 @@
+import { DataSet } from '../DataSet/types';
+import { FieldFilterOptions } from '../DataSet/fieldFilterOptions';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { Section as ConstSection, Pagination } from '../ComponentInterface/types/namespaces.types';
+export type Section<Type> = ConstSection<Type> & {
+    testId?: string;
+    namespace?: string;
+};
+type MetricOptions = {
+    allowsMultiple?: boolean;
+    maximumMetricsAllowed?: number;
+    propKey?: 'xMeasure' | 'yMeasure' | 'zMeasure' | 'measure' | 'barMeasure' | 'lineMeasure';
+    filterFieldOptions?: FieldFilterOptions;
+};
+export type FieldCollectorOptions<Attrs> = {
+    callToAction?: string;
+    maxAllowed?: number;
+    preventDuplicates?: boolean;
+    fieldFilterOptions?: FieldFilterOptions;
+    getValues: (attributes: Attrs) => Array<QueryAttributes['measure'][number] | QueryAttributes['dimension'][number]>;
+    preSetPartialAttributes: (values: Array<QueryAttributes['measure'][number] | QueryAttributes['dimension'][number]>, dataSet: DataSet, originalAttributes: Attrs) => Partial<Attrs>;
+};
+export type FieldCollectorSection = Section<'fieldCollector'> & FieldCollectorOptions<any>;
+export type MetricsSection = Section<'metrics'> & MetricOptions;
+export type DimensionSection = Section<'dimension'> & {
+    newCallToAction?: string;
+    allowsMultiple?: boolean;
+    filterFieldOptions?: FieldFilterOptions;
+};
+export type LabelledMetricSection = Section<'labelledMetrics'> & {
+    subSection: Array<MetricOptions & {
+        title: string;
+    }>;
+};
+export interface ProgressGoalSection<T> extends Omit<Section<T>, 'type'> {
+    goals?: {
+        field: string;
+        value: number;
+    }[];
+}
+export type ProgressGoalsSection = Section<'progressGoals'> & ProgressGoalSection<'progressGoals'>;
+export type PaginationSection = Section<'pagination'> & Pagination;
+export type DataPanelSection = DimensionSection | FieldCollectorSection | LabelledMetricSection | MetricsSection | PaginationSection | ProgressGoalsSection | Section<'comboChartDimension'> | Section<'comparison'> | Section<'country'> | Section<'customMetrics'> | Section<'dataSet'> | Section<'dateComparison'> | Section<'drilldown'> | Section<'fields'> | Section<'filter'> | Section<'limit'> | Section<'sort'> | Section<'timeDimension'> | Section<'views'> | Section<'xAxis'>;
+export type DataPanelConfig = Array<DataPanelSection>;
+export {};

package/dist/types/shared-logic/src/DataSet/DataSet.d.ts

@@ -0,0 +1,45 @@
+import { DataSet } from './types';
+import { CustomField, SimpleMathField } from '../CustomField/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+import { PreAggregatedQuery } from '../Query/types';
+import { QueryAttributes } from '../QueryAttributes/types';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { ComponentType } from '../Component/types';
+import { RawDashboard } from '../Dashboard';
+export declare const find: <T extends {
+    id: string;
+}>(dataSets: Array<T>, dataSetId: string) => T | null;
+export declare const findByName: <T extends {
+    name: string;
+}>(dataSets: Array<T>, dataSetName: string) => T | null;
+export declare const findField: (dataSet: DataSet, id: string) => DataSet.Field;
+export declare const isField: (dataSet: DataSet, id: string) => DataSet.Field | undefined;
+export declare const findFieldByName: (dataSet: DataSet, name: string) => DataSet.Field;
+export declare const findDataSet: (dataSets: DataSet[], dataSetId: string) => [DataSet | null, number];
+export declare const upcastDataSet: (rawDataSet: any, queryEngineConfig: QueryEngineConfig) => DataSet;
+export declare const upcastDataSets: (rawDataSet: any[], queryEngineConfig: QueryEngineConfig) => DataSet[];
+export declare const hasDateTimeFields: (dataSet: DataSet) => boolean;
+export declare const getPlaceholder: (dataSet: DataSet, field: string | null) => string;
+export declare const takeFieldsForDimension: (dataSet: DataSet) => DataSet.Field[];
+export declare const takeFieldsForMeasure: (dataSet: DataSet, componentType: ComponentType) => DataSet.Field[];
+/**
+ * Return all custom fields for a data set, and optionally
+ * provide the componentType to ensure the custom fields which are returned
+ * are also supported by the componentType.
+ */
+export declare const takeCustomFields: (dataSet: DataSet, componentType?: ComponentType) => CustomField[];
+export declare const takeNonCustomFields: (dataSet: DataSet) => Array<NonDateTimeField | DateTimeField | SimpleMathField>;
+export declare const takeNonPercentageCustomFields: (dataSet: DataSet) => Array<NonDateTimeField | DateTimeField | SimpleMathField>;
+export declare const removeCustomFields: (dataSet: DataSet) => DataSet;
+export declare const upsertField: (dataSet: DataSet, upsertedField: DataSet.Field) => DataSet;
+export declare const updateDataSet: (dataSets: DataSet[], updatedDataSet: DataSet) => DataSet[];
+export declare const removeField: <T extends {
+    fields: DataSet["fields"];
+}>(dataSet: T, fieldId: string) => T;
+export declare const findRemovedFieldsBetweenDataSets: (previousDataSets: DataSet[], newDataSets: DataSet[]) => Array<DataSet.Field>;
+export declare const findRemovedFields: (original: DataSet, latest: DataSet) => Array<DataSet.Field>;
+export declare const buildQueryAttributes: (dataSet: DataSet, queryEngineConfig: QueryEngineConfig, componentType: ComponentType) => QueryAttributes;
+export declare const buildDownloadQuery: (dataSet: DataSet, maxCSVDownloadLimit: number, viewFilters: QueryAttributes["filter"]) => QueryAttributes;
+export declare const buildViewOnlyQuery: (dataSet: DataSet) => PreAggregatedQuery;
+export declare const addCustomFields: (dataSets: Array<DataSet>, customFields: RawDashboard["definition"]["customFields"]) => Array<DataSet>;
+export declare const validId: (id: string, dataSet: DataSet[]) => boolean;

package/dist/types/shared-logic/src/DataSet/fieldFilterOptions.d.ts

@@ -0,0 +1,17 @@
+import { ComponentType } from '../Component/types';
+import { DataType } from '../Field/types';
+export type FieldFilterOptions = {
+    removePercentage?: boolean;
+    removeRuleGrouping?: boolean;
+    removeRoundedNumbers?: boolean;
+    removeSimpleMaths?: boolean;
+    removeAggregateMaths?: boolean;
+    removeDateCalculations?: boolean;
+    removeConditional?: boolean;
+    removeCustomBuildMetric?: boolean;
+    removeAggregateCustomBuildMetric?: boolean;
+    onlyDimensions?: boolean;
+    onlyMeasures?: boolean;
+    forComponent?: ComponentType;
+    onlyFieldTypes?: DataType[];
+};

package/dist/types/shared-logic/src/DataSet/filterFields.d.ts

@@ -0,0 +1,3 @@
+import { DataSet } from './types';
+import { FieldFilterOptions } from './fieldFilterOptions';
+export declare function filterFields(originalFields: DataSet.Field[], options?: FieldFilterOptions): DataSet.Field[];

package/dist/types/shared-logic/src/DataSet/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DataSet';
+export * from './newField';
+export * from './filterFields';

package/dist/types/shared-logic/src/DataSet/newField.d.ts

@@ -0,0 +1,15 @@
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+export type FieldOverrides = Partial<{
+    canBeDimension: boolean;
+    canBeMeasure: boolean;
+    allowedOperators: Array<string>;
+}>;
+export type DateTimeFieldOverrides = FieldOverrides & Partial<{
+    allowedGranularities: Array<string>;
+}>;
+export declare const stringField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const numberField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const stringArrayField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const booleanField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides?: FieldOverrides) => NonDateTimeField;
+export declare const dateTimeField: (queryEngineConfig: QueryEngineConfig, id: string, publicName: string, overrides: DateTimeFieldOverrides) => DateTimeField;

package/dist/types/shared-logic/src/DataSet/types.d.ts

@@ -0,0 +1,19 @@
+import { CustomField } from '../CustomField/types';
+import { DateTimeField, NonDateTimeField } from '../Field/types';
+import { PartialBy } from '../typeHelpers';
+export declare namespace DataSet {
+    type Field = DateTimeField | NonDateTimeField | CustomField;
+    type PreUpcastField = PartialBy<DateTimeField, 'allowedGranularities' | 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'> | PartialBy<NonDateTimeField, 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'> | PartialBy<CustomField, 'allowedOperators' | 'canBeDimension' | 'canBeMeasure' | 'supportedAggregateOptions'>;
+}
+export type DataSet<Field = DataSet.Field> = {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Hide the data set from the editor. This allows data sets to be used to power dashboard
+     * filters, but not used to create views on.
+     * */
+    hide?: boolean;
+    fields: Field[];
+    preAggregated?: undefined | false | string[];
+};

package/dist/types/shared-logic/src/DataTable/attributesSchema.d.ts

@@ -0,0 +1,3 @@
+import Joi from '@vizzly/joi';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+export declare const attributesSchema: (config: ComponentInterfaceConfig) => Joi.ObjectSchema<any>;

package/dist/types/shared-logic/src/DataTable/constants.d.ts

@@ -0,0 +1,3 @@
+import { ViewConstants } from '../ComponentInterface/types/namespaces.types';
+declare const CONSTANTS: ViewConstants;
+export default CONSTANTS;

package/dist/types/shared-logic/src/DataTable/index.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { LoadComponentInterface } from '../ComponentInterface/types';
+declare const DataTable: LoadComponentInterface<Component.DataTableAttributes, Component.DataTableAttributes>;
+export default DataTable;

package/dist/types/shared-logic/src/DataTable/setAttributes.d.ts

@@ -0,0 +1,4 @@
+import { Component } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+declare const _default: (config: ComponentInterfaceConfig) => (dataTable: Component.DataTableAttributes, partial: Partial<Component.DataTableAttributes>) => Component.DataTableAttributes;
+export default _default;

package/dist/types/shared-logic/src/DataTable/shared.contants.d.ts

@@ -0,0 +1 @@
+export declare const ROW_NUMBER_OPTIONS: number[];

package/dist/types/shared-logic/src/DataTable/types.d.ts

@@ -0,0 +1,26 @@
+import { Result } from '../Result/types';
+import type { DatumKey } from '../DatumKey';
+export type GroupedTitle = {
+    colSpan: number;
+    content: string;
+    rowGroup?: boolean;
+    unformatted: string;
+};
+export type TableContent = {
+    value: any;
+    displayValue?: any;
+};
+export type TableFields = Result['fields'][number] & {
+    datumKey: DatumKey;
+};
+export type TableRepresentation = {
+    groupTitles?: {
+        consolidated: Array<GroupedTitle>;
+        unconsolidated: Array<GroupedTitle>;
+    } | false;
+    fields: Array<TableFields>;
+    content: TableContent[][];
+};
+export type TableFieldsV2 = {
+    [key: string]: string | number;
+};

package/dist/types/shared-logic/src/DateTime/types.d.ts

@@ -0,0 +1,10 @@
+export type CustomDateTimeRange = {
+    description: string;
+    range: {
+        after: Date;
+        before: Date;
+    };
+};
+export type DateTimeFilterOptions = {
+    [key: string]: boolean | CustomDateTimeRange;
+};

package/dist/types/shared-logic/src/DateTimeField/DateTimeField.d.ts

@@ -0,0 +1,2 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+export declare const filterIsDate: (filter: QueryAttributes.Filter) => boolean;

package/dist/types/shared-logic/src/DatumKey/DatumKey.d.ts

@@ -0,0 +1,15 @@
+export type Datum = {
+    [key: string]: string | number | any;
+};
+export type DatumKey = string;
+export type ParsedDatumKey = {
+    dimensionKeys: Array<string>;
+    dimensionValues: Array<string | number | null | string[]>;
+    fieldId: string;
+    function: string;
+    modifier?: string;
+};
+export declare const key: (dimensionKeys: ParsedDatumKey["dimensionKeys"], dimensionValues: ParsedDatumKey["dimensionValues"], fieldId: ParsedDatumKey["fieldId"], func: ParsedDatumKey["function"]) => string;
+export declare const isDatumKey: (key: string | undefined) => boolean;
+export declare const parse: (key: string) => ParsedDatumKey;
+export declare const toFieldId: (key: string) => string;

package/dist/types/shared-logic/src/DatumKey/index.d.ts

@@ -0,0 +1 @@
+export * from './DatumKey';

package/dist/types/shared-logic/src/Display/Display.d.ts

@@ -0,0 +1,23 @@
+import { Component, ComponentType } from '../Component/types';
+import { Display, DisplayRow, EmptyCell } from './types';
+import { HeaderComponent } from '../Header/types';
+export { removeAllFieldReferences } from './removeAllFieldReferences';
+export declare const allComponentsInDirection: (display: Display, rowIndex: number, cellIndex: number, direction: "left" | "right") => Array<Component | EmptyCell | HeaderComponent>;
+export declare const getNextComponentIndexWithSpace: (display: Display, rowIndex: number, cellIndex: number, direction: "left" | "right") => number;
+export declare const insertRow: (display: Display, rowIndex: number, height?: number) => Display;
+export declare const newEmptyCell: (colSpan: number) => EmptyCell;
+export declare const TOTAL_COLSPAN = 12;
+export declare const appendEmptyCell: (currentPanels: Display, rowIndex: number) => Display;
+export declare const setComponent: (display: Display, component: Component | EmptyCell | HeaderComponent, rowIndex: number, cellIndex: number) => Display;
+type Move = {
+    rowIndex: number;
+    cellIndex: number;
+};
+export declare const swapComponents: (display: Display, positionA: Move, positionB: Move) => Display;
+export declare const init: () => Display;
+export declare const initRow: (components: Array<Component | EmptyCell | HeaderComponent>, height?: number) => DisplayRow;
+export declare const listComponentTypesUsed: (display: Display) => ComponentType[];
+export declare const isComponentEmpty: (component: Component | EmptyCell | HeaderComponent) => component is EmptyCell;
+export declare function isDisplayComponentsEmpty(display: Display): boolean;
+export declare const moveDisplayToNewIndex: (display: DisplayRow[], movingIndex: number, destinationIndex: number) => DisplayRow[];
+export declare const countNonHeaderRows: (display: Display) => number;

package/dist/types/shared-logic/src/Display/dumpable.d.ts

@@ -0,0 +1,5 @@
+import { Dumpable } from '../Dumpable';
+import { Display, DisplayDumped } from './types';
+export type DumpableDisplay = Dumpable<Display, DisplayDumped>;
+export declare const load: DumpableDisplay['load'];
+export declare const dump: DumpableDisplay['dump'];

package/dist/types/shared-logic/src/Display/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Display';
+export * from './dumpable';

package/dist/types/shared-logic/src/Display/removeAllFieldReferences.d.ts

@@ -0,0 +1,3 @@
+import { Display } from './types';
+import { DataSet } from '../DataSet/types';
+export declare const removeAllFieldReferences: (display: Display, fieldsToRemove: DataSet.Field[]) => Display;

package/dist/types/shared-logic/src/Display/types.d.ts

@@ -0,0 +1,15 @@
+import { Component } from '../Component/types';
+import { HeaderComponent } from '../Header/types';
+export type EmptyCell = {
+    isEmpty: true;
+    colSpan: number;
+};
+export type DisplayRow = {
+    components: Array<Component | EmptyCell | HeaderComponent>;
+    height: number;
+};
+export type Display = DisplayRow[];
+export type DisplayDumped = Array<{
+    components: Array<Component.RawComponent | EmptyCell | HeaderComponent>;
+    height: number;
+}>;

package/dist/types/shared-logic/src/Display/upcast.d.ts

@@ -0,0 +1,7 @@
+import { DisplayRow, EmptyCell } from './types';
+import { Component as ComponentType } from '../Component/types';
+import { ComponentInterfaceConfig } from '../ComponentInterface/types';
+import { HeaderComponent } from '../Header/types';
+type OldDisplayRow = (ComponentType | null | EmptyCell | HeaderComponent)[];
+export declare const upcastRow: (displayRow: OldDisplayRow | DisplayRow, componentInterfaceConfig?: ComponentInterfaceConfig) => DisplayRow;
+export {};

package/dist/types/shared-logic/src/Drilldown/schema.d.ts

@@ -0,0 +1,3 @@
+import Joi from '@vizzly/joi';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+export declare function drilldownSchema(queryEngineConfig: QueryEngineConfig): Joi.SchemaLike<any> | Joi.SchemaLike<any>[] | undefined;

package/dist/types/shared-logic/src/Dumpable.d.ts

@@ -0,0 +1,5 @@
+import { ComponentInterfaceConfig } from './ComponentInterface/types/ComponentInterfaceConfig';
+export interface Dumpable<Hydrated, Dumped> {
+    dump: (hydrated: Hydrated) => Dumped;
+    load: (dumped: Dumped, componentInterfaceConfig?: ComponentInterfaceConfig) => Hydrated;
+}

package/dist/types/shared-logic/src/Field/Field.d.ts

@@ -0,0 +1,102 @@
+import { DataSet } from '../DataSet/types';
+import { DateTimeField, NonDateTimeField, SupportedAggregateOption } from '../Field/types';
+import { DataType } from './types';
+import { QueryAttributes, SupportedOperators } from '../QueryAttributes/types';
+import { SupportedAggregates } from '../Aggregate';
+import { SupportedTimeTruncFunctions } from '@vizzly/semantic-layer-public';
+import { QueryEngineConfig } from '../QueryEngineConfig/types';
+import { SupportedTransformationFunctions } from '../Functions/types';
+import { TextOverride } from '../Translations/types';
+import { ValueAlias as ValueAliasType } from '../ValueAlias/types';
+export declare const NULL_REPLACEMENT = "No value";
+export declare const ALL_AGGREGATES: Array<QueryAttributes.Aggregate>;
+export type OldField = {
+    id: string;
+    publicName?: string;
+    dataType: 'string' | 'number' | 'date_time' | 'boolean' | 'string[]';
+    canBeDimension?: boolean;
+    canBeMeasure?: boolean;
+    allowedGranularities?: QueryAttributes.TimeDimension.Truncate[];
+    allowedOperators?: Array<QueryAttributes.Operator>;
+    dashboardRequiredFilterGroups?: Array<{
+        publicName: string;
+    }>;
+    supportedAggregateOptions?: string[];
+    description?: string;
+};
+export declare const upcastField: (maybeOldField: OldField, queryEngineConfig: QueryEngineConfig, options?: {
+    allowEmptyPublicName: boolean;
+}) => DateTimeField | NonDateTimeField;
+export declare const valueIsOrDataType: (value: unknown, dataType: DataType) => boolean;
+export declare const parseValue: (raw: string | number | null | boolean | Date | string[], type: DataType) => string | number | boolean | Date | null;
+export declare const parseBooleanFromString: (raw: string, type: DataType) => string | boolean;
+export declare const VALID_DATA_TYPES: DataType[];
+export declare const isValidDataType: (type: string) => boolean;
+export declare const toHumanReadable: (fieldTitle: string) => string;
+export declare const dataTypeToHumanReadable: (dataType: DataType) => string;
+export declare const toString: (value: null | string | number | Date | boolean | string[], formatDate?: (date: Date) => string, nullReplacement?: string) => string | null;
+export declare const toStringShort: (value: null | string | number | Date, nullReplacement?: string) => string | number;
+export declare const removeFields: <T extends {
+    id: string;
+}>(originalFields: {
+    id: string;
+}[], fieldTitlesToRemove: string[]) => T[];
+export declare const supportedOperators: (field: DataSet.Field, supportedOperators: QueryEngineConfig["supportedOperators"], textOverride?: TextOverride) => SupportedOperators;
+export declare const getDefaultAggregateForField: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+}, supportedAggregates: T) => string;
+export declare const supportedAggregatesForField: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+    supportedAggregateOptions?: SupportedAggregateOption[];
+}, supportedAggregates: T) => Array<string>;
+export declare const supportedAggregateOptions: <T extends SupportedAggregates>(field: {
+    dataType: DataType;
+}, supportedAggregates: T) => Array<{
+    label: string;
+    value: keyof T;
+}>;
+export declare const timeDimensionTruncateToSelectOptions: (allowedTimeDimensionGranularities: QueryAttributes.TimeDimension.Truncate[], supportedTimeTruncFunctions: SupportedTimeTruncFunctions) => {
+    label: string;
+    value: QueryAttributes.TimeDimension.Truncate;
+}[];
+export declare const takeHighestGranularity: (timeDimensionGranularities: QueryAttributes.TimeDimension.Truncate[]) => QueryAttributes.TimeDimension.Truncate;
+/**
+ * Build the id of the field in string format
+ */
+export declare const id: (metric: {
+    field: string;
+    function: string;
+}) => string;
+export type DecodingFunctionsToCheck = {
+    supportedAggregates: QueryEngineConfig['supportedAggregates'] | undefined;
+    supportedTimeTruncFunctions: QueryEngineConfig['supportedTimeTruncFunctions'] | undefined;
+    supportedTransformationFunctions: QueryEngineConfig['supportedTransformationFunctions'] | undefined;
+};
+/**
+ * Decode a built id of the field. Requires all possible functions to be
+ * able to do this.
+ */
+export declare const decodeId: (metric: string, functionsToCheck: DecodingFunctionsToCheck) => QueryAttributes.Measure;
+/**
+ * @deprecated
+ * Use decodeId instead.
+ * */
+export declare const getQueryFieldIdFromResultFieldId: (fieldIdOrDatumKey: string, functionsToCheck: DecodingFunctionsToCheck) => {
+    fieldId: string;
+    function: QueryAttributes.Aggregate;
+};
+export declare const listValidFunctionsForDataType: (field: {
+    dataType: DataType;
+}, supportedTransformationFunctions: SupportedTransformationFunctions | SupportedAggregates) => string[];
+export declare const removeField: <T extends {
+    id: string;
+}>(originalFields: T[], removeFields: (QueryAttributes.Dimension | QueryAttributes.Measure)[]) => T[];
+export declare const upcastStringDimensionsToObject: (dimensions: QueryAttributes.Dimension[]) => QueryAttributes.Dimension[];
+export declare const isArrayDataType: (field: {
+    dataType: DataType;
+}) => boolean;
+declare const vizzlySupportedTransformationFunctions: SupportedTransformationFunctions;
+export declare const supportedTransformationFunctions: (keys?: Array<keyof typeof vizzlySupportedTransformationFunctions>) => SupportedTransformationFunctions;
+export declare const supportedAggregatesFunction: (queryEngineConfig: QueryEngineConfig, dataType: DataType, supportedAggregateOptions?: SupportedAggregateOption[]) => SupportedAggregateOption[];
+export declare const checkForNullValue: (dataSetId: string, dimensions: QueryAttributes.Dimension[] | null, timeDimension: QueryAttributes.TimeDimension | null, textOverride?: TextOverride, valueAlias?: ValueAliasType, textOverrideKey?: string) => string | undefined;
+export {};

package/dist/types/shared-logic/src/Field/index.d.ts

@@ -0,0 +1 @@
+export * from './Field';

package/dist/types/shared-logic/src/Field/types.d.ts

@@ -0,0 +1,26 @@
+import { QueryAttributes } from '../QueryAttributes/types';
+export type DataType = 'number' | 'boolean' | 'string' | 'date_time' | 'string[]';
+export type DateTimeFormat = 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'DD MMMM YYYY, hh:mm' | 'dddd DD MMMM YYYY, hh:mm' | 'hh:mm' | 'hh:mm:ss' | 'DD MMMM YYYY' | 'MMMM YYYY' | 'YYYY' | 'YYYY-MM-DD[T]HH:mm:ss' | 'quarter' | 'week' | 'day_of_month' | 'day_of_week_iso' | 'week_of_year' | 'hour_of_day' | 'month_of_year';
+export type SupportedAggregateOption = string;
+type DashboardRequiredFilterGroup = {
+    /** This is displayed on the global filter, and it is also used to group related filters */
+    publicName: string;
+};
+export type BaseField = {
+    id: string;
+    publicName: string;
+    description?: string;
+    canBeDimension: boolean;
+    canBeMeasure: boolean;
+    allowedOperators: Array<QueryAttributes.Operator>;
+    dashboardRequiredFilterGroups?: DashboardRequiredFilterGroup[];
+    supportedAggregateOptions?: SupportedAggregateOption[];
+};
+export type DateTimeField = BaseField & {
+    dataType: 'date_time';
+    allowedGranularities: QueryAttributes.TimeDimension.Truncate[];
+};
+export interface NonDateTimeField extends BaseField {
+    dataType: Exclude<DataType, 'date_time'>;
+}
+export {};