@uipath/apollo-vertex 0.0.0-stage → 0.1.0

package/dist/registry/charts-core/models/configurations/table-chart-configuration.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const TableChartConfigurationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        valueType: z.ZodLiteral<"datetime">;
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        range: z.ZodObject<{
+            min: z.ZodCustom<import("luxon").DateTime<true>, import("luxon").DateTime<true>>;
+            max: z.ZodCustom<import("luxon").DateTime<true>, import("luxon").DateTime<true>>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"number">;
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        range: z.ZodUnion<readonly [z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"string">;
+        type: z.ZodLiteral<"search">;
+        field: z.ZodString;
+        pattern: z.ZodString;
+        searchFilterType: z.ZodEnum<{
+            endsWith: "endsWith";
+            startsWith: "startsWith";
+            default: "default";
+        }>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        valueType: z.ZodLiteral<"string">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"boolean">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"number">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>]>>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    from: z.ZodOptional<z.ZodObject<{
+        entity: z.ZodString;
+        alias: z.ZodString;
+    }, z.core.$strip>>;
+    filterTableId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"table">;
+    dimensions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type TableChartConfiguration = z.infer<typeof TableChartConfigurationSchema>;

package/dist/registry/charts-core/models/configurations/table-chart-configuration.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { BaseChartConfigurationSchema } from "./base-chart-configuration.js";
+const TableChartConfigurationSchema = BaseChartConfigurationSchema.extend({
+    type: z.literal("table"),
+    dimensions: z.array(z.string())
+});
+export { TableChartConfigurationSchema };

package/dist/registry/charts-core/models/expression.d.ts

@@ -0,0 +1,11 @@
+import type { DataModelField } from "./field";
+import type { FilterValues } from "./filter-values";
+export type AggregationKind = "ANY" | "DISTINCT_COUNT" | "COUNT" | "AVERAGE" | "MIN" | "MAX" | "PERCENTAGE" | "SUM" | "PERCENTILE" | "MEDIAN";
+export interface DataModelAggregate {
+    id?: string;
+    type: "aggregate";
+    aggregation: AggregationKind;
+    argument: DataModelField;
+    filters?: FilterValues[];
+}
+export type MetricExpression = DataModelAggregate;

package/dist/registry/charts-core/models/field.d.ts

@@ -0,0 +1,44 @@
+interface BaseField {
+    id: string;
+    display: string;
+}
+interface NumericField extends BaseField {
+    type: "numeric";
+}
+interface StringField extends BaseField {
+    type: "string";
+}
+interface DateTimeField extends BaseField {
+    type: "datetime";
+}
+interface PercentageField extends BaseField {
+    type: "percentage";
+}
+interface DurationField extends BaseField {
+    type: "duration";
+}
+interface CurrencyField extends BaseField {
+    type: "currency";
+    format?: {
+        currency: string;
+    };
+}
+interface BooleanField extends BaseField {
+    type: "boolean";
+    format?: {
+        trueDisplay: string;
+        falseDisplay: string;
+    };
+}
+export type DataModelField = NumericField | StringField | DateTimeField | PercentageField | DurationField | CurrencyField | BooleanField;
+export type DataModelFieldType = DataModelField["type"];
+export type DatetimeModelField = Extract<DataModelField, {
+    type: "datetime";
+}>;
+export type StringModelField = Extract<DataModelField, {
+    type: "string";
+}>;
+export type NumericOrDatetimeModelField = Extract<DataModelField, {
+    type: "numeric" | "datetime";
+}>;
+export {};

package/dist/registry/charts-core/models/filter-values.d.ts

@@ -0,0 +1,53 @@
+import type { DateTime } from "luxon";
+type FilterType = "range" | "list" | "search" | "period";
+interface BaseFilter {
+    type: FilterType;
+}
+export interface PeriodFilterValues extends BaseFilter {
+    type: "period";
+    field: string;
+    range: {
+        min: DateTime;
+        max: DateTime;
+        inclusive?: boolean;
+    };
+}
+export interface NumberRangeFilterValues extends BaseFilter {
+    type: "range";
+    field: string;
+    range: {
+        min: number;
+        max?: number;
+        inclusive?: boolean;
+    } | {
+        min?: number;
+        max: number;
+        inclusive?: boolean;
+    };
+}
+export interface StringSearchFilterValues extends BaseFilter {
+    type: "search";
+    field: string;
+    pattern: string;
+    searchFilterType: "default" | "startsWith" | "endsWith";
+}
+interface ListFilterBase extends BaseFilter {
+    type: "list";
+    field: string;
+    invert?: boolean;
+}
+export interface StringListFilterValues extends ListFilterBase {
+    valueType: "string";
+    values: (string | null)[];
+}
+export interface BooleanListFilterValues extends ListFilterBase {
+    valueType: "boolean";
+    values: (boolean | null)[];
+}
+export interface NumberListFilterValues extends ListFilterBase {
+    valueType: "number";
+    values: (number | null)[];
+}
+export type ListFilterValues = StringListFilterValues | BooleanListFilterValues | NumberListFilterValues;
+export type FilterValues = PeriodFilterValues | NumberRangeFilterValues | ListFilterValues | StringSearchFilterValues;
+export {};

package/dist/registry/charts-core/models/filter.d.ts

@@ -0,0 +1,14 @@
+import type { DataModelField } from "../chart-models";
+interface BaseFilter {
+    display: string;
+    id: string;
+}
+export interface ListFilter extends BaseFilter {
+    type: "list";
+    field: DataModelField;
+}
+export interface PeriodFilter extends BaseFilter {
+    type: "period";
+    field: DataModelField;
+}
+export {};

package/dist/registry/charts-core/models/join-schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const JoinConfigSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        INNER: "INNER";
+        LEFT: "LEFT";
+    }>;
+    entity: z.ZodString;
+    alias: z.ZodOptional<z.ZodString>;
+    on: z.ZodObject<{
+        left: z.ZodString;
+        right: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const FromConfigSchema: z.ZodObject<{
+    entity: z.ZodString;
+    alias: z.ZodString;
+}, z.core.$strip>;
+export interface JoinConfig {
+    type: "INNER" | "LEFT";
+    entity: string;
+    alias?: string;
+    on: {
+        left: string;
+        right: string;
+    };
+}
+export interface FromConfig {
+    entity: string;
+    alias: string;
+}

package/dist/registry/charts-core/models/join-schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+const JoinConfigSchema = z.object({
+    type: z["enum"]([
+        "INNER",
+        "LEFT"
+    ]),
+    entity: z.string(),
+    alias: z.string().optional(),
+    on: z.object({
+        left: z.string(),
+        right: z.string()
+    })
+});
+const FromConfigSchema = z.object({
+    entity: z.string(),
+    alias: z.string()
+});
+export { FromConfigSchema, JoinConfigSchema };

package/dist/registry/charts-core/models/primitive-value.d.ts

@@ -0,0 +1 @@
+export type PrimitiveValue = string | boolean | number | null;

package/dist/registry/charts-core/spinner-with-children.d.ts

@@ -0,0 +1,6 @@
+import type { PropsWithChildren } from "react";
+interface CenteredSpinnerProps {
+    loading: boolean;
+}
+export declare const SpinnerWithChildren: ({ children, loading, }: PropsWithChildren<CenteredSpinnerProps>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/charts-core/spinner-with-children.js

@@ -0,0 +1,18 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Spinner } from "../spinner/spinner.js";
+const SpinnerWithChildren = ({ children, loading })=>/*#__PURE__*/ jsxs("div", {
+        className: "relative flex h-full w-full items-center",
+        children: [
+            loading && /*#__PURE__*/ jsx("div", {
+                className: "absolute z-[2] flex h-full w-full items-center justify-center",
+                children: /*#__PURE__*/ jsx(Spinner, {
+                    className: "size-10"
+                })
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: `flex h-full w-full items-center justify-center ${loading ? "bg-background opacity-30" : ""}`,
+                children: children
+            })
+        ]
+    });
+export { SpinnerWithChildren };

package/dist/registry/charts-core/table-data-model.d.ts

@@ -0,0 +1,6 @@
+import type { DataModelField } from "./models/field";
+export type TableDataModelField = DataModelField;
+export interface TableDataModel {
+    id: string;
+    fields: Array<DataModelField>;
+}

package/dist/registry/charts-core/util/binning/adaptive-bin-formatting.d.ts

@@ -0,0 +1,2 @@
+import type { Interval } from "luxon";
+export declare const adaptiveBinFormatting: (locale: Intl.LocalesArgument, bin: Interval, chartRange: Interval) => string;

package/dist/registry/charts-core/util/binning/adaptive-bin-formatting.js

@@ -0,0 +1,31 @@
+import { formatDate } from "../format/format-date.js";
+function getDateTimeFormat(binRange, chartRange) {
+    const { start, end } = binRange;
+    const { start: chartStart, end: chartEnd } = chartRange;
+    const hasMultipleDays = !chartStart.hasSame(chartEnd, "day");
+    const diff = end.diff(start);
+    const isShowingTime = diff.as("day") < 1;
+    if (isShowingTime && hasMultipleDays) return {
+        month: "short",
+        day: "numeric"
+    };
+    if (isShowingTime) return {
+        timeStyle: "short",
+        hourCycle: "h23"
+    };
+    const isShowingMonthDay = diff.as("month") < 1;
+    if (isShowingMonthDay) return {
+        month: "short",
+        day: "numeric"
+    };
+    return {
+        month: "short",
+        year: "numeric"
+    };
+}
+const adaptiveBinFormatting = (locale, bin, chartRange)=>{
+    const value = bin.start;
+    const formatSettings = getDateTimeFormat(bin, chartRange);
+    return formatDate(locale, value, formatSettings);
+};
+export { adaptiveBinFormatting };

package/dist/registry/charts-core/util/binning/constants.d.ts

@@ -0,0 +1,5 @@
+import { Duration } from "luxon";
+export declare const NICE_NUMBER_CATEGORIES: number[];
+export declare const MAX_BINS = 20;
+export declare const TARGET_BINS = 15;
+export declare const DATE_TIME_NUMBER_CATEGORIES: Duration<true>[];

package/dist/registry/charts-core/util/binning/constants.js

@@ -0,0 +1,122 @@
+import { Duration } from "luxon";
+const NICE_NUMBER_CATEGORIES = [
+    1,
+    2,
+    3,
+    4,
+    5,
+    25
+];
+const MAX_BINS = 20;
+const TARGET_BINS = 15;
+const DATE_TIME_NUMBER_CATEGORIES = [
+    Duration.fromObject({
+        years: 500
+    }),
+    Duration.fromObject({
+        years: 100
+    }),
+    Duration.fromObject({
+        years: 50
+    }),
+    Duration.fromObject({
+        years: 10
+    }),
+    Duration.fromObject({
+        years: 5
+    }),
+    Duration.fromObject({
+        years: 2
+    }),
+    Duration.fromObject({
+        years: 1
+    }),
+    Duration.fromObject({
+        months: 6
+    }),
+    Duration.fromObject({
+        months: 4
+    }),
+    Duration.fromObject({
+        months: 3
+    }),
+    Duration.fromObject({
+        months: 2
+    }),
+    Duration.fromObject({
+        months: 1
+    }),
+    Duration.fromObject({
+        days: 14
+    }),
+    Duration.fromObject({
+        days: 7
+    }),
+    Duration.fromObject({
+        days: 4
+    }),
+    Duration.fromObject({
+        days: 2
+    }),
+    Duration.fromObject({
+        days: 1
+    }),
+    Duration.fromObject({
+        hours: 12
+    }),
+    Duration.fromObject({
+        hours: 6
+    }),
+    Duration.fromObject({
+        hours: 4
+    }),
+    Duration.fromObject({
+        hours: 2
+    }),
+    Duration.fromObject({
+        hours: 1
+    }),
+    Duration.fromObject({
+        minutes: 30
+    }),
+    Duration.fromObject({
+        minutes: 20
+    }),
+    Duration.fromObject({
+        minutes: 15
+    }),
+    Duration.fromObject({
+        minutes: 10
+    }),
+    Duration.fromObject({
+        minutes: 5
+    }),
+    Duration.fromObject({
+        minutes: 4
+    }),
+    Duration.fromObject({
+        minutes: 2
+    }),
+    Duration.fromObject({
+        minutes: 1
+    }),
+    Duration.fromObject({
+        seconds: 30
+    }),
+    Duration.fromObject({
+        seconds: 10
+    }),
+    Duration.fromObject({
+        seconds: 1
+    }),
+    Duration.fromObject({
+        milliseconds: 100
+    }),
+    Duration.fromObject({
+        milliseconds: 30
+    }),
+    Duration.fromObject({
+        milliseconds: 1
+    })
+];
+export { DATE_TIME_NUMBER_CATEGORIES, MAX_BINS, NICE_NUMBER_CATEGORIES, TARGET_BINS };

package/dist/registry/charts-core/util/binning/nice-duration-numbers.d.ts

@@ -0,0 +1,6 @@
+import type { DateTime } from "luxon";
+import { Duration } from "luxon";
+export declare function niceDurationNumbers({ min, max, }: {
+    min: DateTime;
+    max: DateTime;
+}): Duration<true>;

package/dist/registry/charts-core/util/binning/nice-duration-numbers.js

@@ -0,0 +1,23 @@
+import { Duration, Interval } from "luxon";
+import { DATE_TIME_NUMBER_CATEGORIES, MAX_BINS, TARGET_BINS } from "./constants.js";
+function niceDurationNumbers({ min, max }) {
+    let bestBinSize = Duration.fromObject({
+        years: 999999999
+    });
+    const interval = Interval.fromDateTimes(min, max);
+    let bestBinDiff = Number.MAX_SAFE_INTEGER;
+    for (const category of DATE_TIME_NUMBER_CATEGORIES){
+        const bins = interval.splitBy(category);
+        const binCount = bins.length;
+        const diffWithTarget = Math.abs(binCount - TARGET_BINS);
+        const isMuchLarger = binCount > 10 * TARGET_BINS;
+        const isInitial = bestBinDiff === Number.MAX_SAFE_INTEGER;
+        if (isMuchLarger && !isInitial) break;
+        if (diffWithTarget < bestBinDiff && binCount <= MAX_BINS) {
+            bestBinDiff = diffWithTarget;
+            bestBinSize = category;
+        }
+    }
+    return bestBinSize;
+}
+export { niceDurationNumbers };

package/dist/registry/charts-core/util/binning/nice-numbers.d.ts

@@ -0,0 +1,7 @@
+export declare function niceNumbers({ min, max }: {
+    min: number;
+    max: number;
+}): {
+    min: number;
+    binSize: number;
+};

package/dist/registry/charts-core/util/binning/nice-numbers.js

@@ -0,0 +1,27 @@
+import { emptyArray } from "../empty-array.js";
+import { MAX_BINS, NICE_NUMBER_CATEGORIES, TARGET_BINS } from "./constants.js";
+function niceNumbers({ min, max }) {
+    let bestBinSize = 1;
+    let bestDistance = Number.MAX_SAFE_INTEGER;
+    const range = max - min;
+    const startOrderOfMagnitude = Math.trunc(Math.log10(range / MAX_BINS)) - 1;
+    const endOrderOfMagnitude = Math.ceil(Math.log10(10 * range));
+    const factorSteps = endOrderOfMagnitude - startOrderOfMagnitude;
+    const factors = emptyArray(factorSteps).map((_, idx)=>10 ** (idx + startOrderOfMagnitude));
+    const binSizes = factors.flatMap((factor)=>NICE_NUMBER_CATEGORIES.map((category)=>category * factor));
+    for (const binSize of binSizes){
+        const binCount = Math.ceil(max / binSize) - Math.floor(min / binSize);
+        if (binCount <= 4 || 3 !== binSize && 4 !== binSize) {
+            const currentDifference = Math.abs(binCount - TARGET_BINS);
+            if (currentDifference < bestDistance && binCount <= MAX_BINS) {
+                bestDistance = currentDifference;
+                bestBinSize = binSize;
+            }
+        }
+    }
+    return {
+        min: Math.floor(min / bestBinSize) * bestBinSize,
+        binSize: bestBinSize
+    };
+}
+export { niceNumbers };

package/dist/registry/charts-core/util/build-field.d.ts

@@ -0,0 +1,4 @@
+import type { DataModelField, DataModelFieldType } from "../models/field";
+export declare function buildField<T extends DataModelFieldType>(id: string, type: T): Extract<DataModelField, {
+    type: T;
+}>;

package/dist/registry/charts-core/util/build-field.js

@@ -0,0 +1,8 @@
+function buildField(id, type) {
+    return {
+        id,
+        display: id,
+        type
+    };
+}
+export { buildField };

package/dist/registry/charts-core/util/data-type-alignment.d.ts

@@ -0,0 +1,4 @@
+import type { DataModelFieldType } from "../chart-models";
+export declare function dataTypeAlignment(field: {
+    type: DataModelFieldType;
+}): "left" | "right";

package/dist/registry/charts-core/util/data-type-alignment.js

@@ -0,0 +1,14 @@
+function dataTypeAlignment(field) {
+    switch(field.type){
+        case "datetime":
+        case "numeric":
+        case "currency":
+        case "percentage":
+        case "duration":
+            return "right";
+        case "boolean":
+        case "string":
+            return "left";
+    }
+}
+export { dataTypeAlignment };

package/dist/registry/charts-core/util/empty-array.d.ts

@@ -0,0 +1 @@
+export declare const emptyArray: (count: number) => unknown[];

package/dist/registry/charts-core/util/empty-array.js

@@ -0,0 +1,4 @@
+const emptyArray = (count)=>Array.from({
+        length: count
+    });
+export { emptyArray };

package/dist/registry/charts-core/util/format/base-format-options.d.ts

@@ -0,0 +1,3 @@
+export type BaseFormatOptions = {
+    notation?: "compact";
+};

package/dist/registry/charts-core/util/format/bin-label-format-setting.d.ts

@@ -0,0 +1,10 @@
+import type { DateTime } from "luxon";
+import type { BaseFormatOptions } from "./base-format-options";
+import type { FormatDurationOptions } from "./format-duration";
+interface BinLabelFormatSettingProps {
+    value: number | DateTime;
+    type: "duration" | "numeric" | "datetime";
+    isCompact?: boolean;
+}
+export declare const binLabelFormatSetting: ({ value, type, isCompact, }: BinLabelFormatSettingProps) => BaseFormatOptions | FormatDurationOptions;
+export {};

package/dist/registry/charts-core/util/format/bin-label-format-setting.js

@@ -0,0 +1,14 @@
+import { Duration } from "luxon";
+import { z } from "zod";
+import { computeDurationUnits } from "./compute-duration-units.js";
+const binLabelFormatSetting = ({ value, type, isCompact = false })=>{
+    if ("duration" === type) return {
+        units: computeDurationUnits(Duration.fromMillis(z.number().parse(value))),
+        compactUnit: isCompact
+    };
+    if (isCompact) return {
+        notation: "compact"
+    };
+    return {};
+};
+export { binLabelFormatSetting };

package/dist/registry/charts-core/util/format/bin-label.d.ts

@@ -0,0 +1,13 @@
+import { DateTime, Interval } from "luxon";
+interface BinLabelProps {
+    locale: Intl.LocalesArgument;
+    type: "duration" | "numeric" | "datetime";
+    bin: {
+        start: number | DateTime;
+        end: number | DateTime;
+    };
+    chartRange?: Interval;
+    isCompact?: boolean;
+}
+export declare const binLabel: ({ locale, bin, type, chartRange, isCompact, }: BinLabelProps) => string;
+export {};