@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/components/Charts/chartImage.d.ts

@@ -0,0 +1,121 @@
+import { type ChartLabels } from './labels';
+import { type GaugeVariant, type TreemapNode, type ColumnMode, type TrendGood } from './geometry';
+import type { ChartDatum, ChartProgressColor, ChartSeries, ChartSlice, ChartColor } from './types';
+import type { NumberTrendPoint } from './NumberTrend';
+import type { CalendarDay } from './CalendarHeatmap';
+export interface ChartImageProgressRow {
+    label: string;
+    value: number;
+    total: number;
+    color?: ChartProgressColor;
+}
+export type ChartImageChart = {
+    kind: 'donut';
+    slices: ChartSlice[];
+} | {
+    kind: 'pie';
+    slices: ChartSlice[];
+} | {
+    kind: 'stacked';
+    slices: ChartSlice[];
+} | {
+    kind: 'bars';
+    data: ChartDatum[];
+    series: ChartSeries[];
+} | {
+    kind: 'columns';
+    data: ChartDatum[];
+    series: ChartSeries[];
+    mode?: ColumnMode;
+} | {
+    kind: 'line';
+    data: ChartDatum[];
+    series: ChartSeries[];
+    area?: boolean;
+} | {
+    kind: 'progress';
+    rows: ChartImageProgressRow[];
+} | {
+    kind: 'treemap';
+    nodes: TreemapNode[];
+} | {
+    kind: 'calendar';
+    days: CalendarDay[];
+} | {
+    kind: 'funnel';
+    steps: ChartSlice[];
+} | {
+    kind: 'gauge';
+    rows: ChartImageProgressRow[];
+    variant?: GaugeVariant;
+} | {
+    kind: 'number';
+    value: number;
+    points?: NumberTrendPoint[];
+    current?: number;
+    previous?: number;
+    good?: TrendGood;
+    slot?: ChartColor;
+};
+export interface ChartImage {
+    report?: string;
+    title: string;
+    context?: string;
+    branding?: string;
+    chart: ChartImageChart;
+    at?: Date;
+    locale?: string;
+    format?: (n: number) => string;
+    labels?: Partial<ChartLabels>;
+}
+export declare const CHART_IMAGE_PALETTE: {
+    background: string;
+    text: string;
+    muted: string;
+    faint: string;
+    line: string;
+    track: string;
+    slots: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        rest: string;
+        positive: string;
+        warning: string;
+        negative: string;
+        info: string;
+        neutral: string;
+    };
+    heat: readonly ["#e8eff9", "#bcd3f2", "#7faee9", "#4081d2", "#155aa7"];
+};
+export declare const CHART_IMAGE_WIDTH = 720;
+export declare const CHART_IMAGE_PIXEL_RATIO = 2;
+export declare const chartImageFonts: (family: string) => {
+    title: string;
+    report: string;
+    big: string;
+    bold: string;
+    text: string;
+    small: string;
+};
+export type ChartImageContext = Pick<CanvasRenderingContext2D, 'font' | 'fillStyle' | 'strokeStyle' | 'lineWidth' | 'textAlign' | 'textBaseline' | 'globalAlpha' | 'lineCap' | 'measureText' | 'fillText' | 'fillRect' | 'beginPath' | 'arc' | 'stroke' | 'moveTo' | 'lineTo' | 'setLineDash' | 'setTransform' | 'fill' | 'closePath' | 'lineJoin'>;
+export interface ChartImageCanvas {
+    width: number;
+    height: number;
+    getContext(kind: '2d'): ChartImageContext | null;
+}
+export declare function paintChartImage(canvas: ChartImageCanvas, image: ChartImage, opts: {
+    fontFamily: string;
+    pixelRatio?: number;
+}): void;
+export declare function chartImageBlob(image: ChartImage, opts?: {
+    fontFamily?: string;
+}): Promise<Blob>;
+export declare function chartImageFileName(title: string, at?: Date, report?: string): string;

package/dist/types/components/Charts/geometry.d.ts

@@ -0,0 +1,180 @@
+import type { ChartColor, ChartDatum, ChartSeries, ChartSlice } from './types';
+export declare const datumKey: (d: ChartDatum) => string;
+export declare const datumTotal: (d: ChartDatum, series: ChartSeries[]) => number;
+export declare const DONUT_RADIUS = 40;
+export declare const DONUT_CIRCUMFERENCE: number;
+export declare const DONUT_STROKE = 16;
+export declare const DONUT_GAP = 1.2;
+export interface DonutArc {
+    slice: ChartSlice;
+    start: number;
+    length: number;
+}
+export declare function donutArcs(slices: ChartSlice[]): DonutArc[];
+export declare const sharePercent: (value: number, total: number) => number;
+export declare function niceMax(v: number): number;
+export declare function columnScale(totals: number[]): {
+    max: number;
+    ticks: number[];
+};
+export declare const barScale: (totals: number[]) => number;
+export declare const showsColumnLabel: (index: number, count: number) => boolean;
+export type ColumnMode = 'stacked' | 'grouped';
+export declare const columnValues: (data: readonly ChartDatum[], series: readonly ChartSeries[], mode?: ColumnMode) => number[];
+export declare function groupedBars(count: number, width: number, gap?: number): Array<{
+    x: number;
+    width: number;
+}>;
+export declare const pointX: (i: number, count: number, width: number) => number;
+export interface LinePoint {
+    x: number;
+    y: number;
+}
+export declare function linePoints(values: readonly number[], width: number, height: number, max: number): LinePoint[];
+export declare const linePath: (points: readonly LinePoint[]) => string;
+export declare function areaPath(points: readonly LinePoint[], baseline: number): string;
+export declare function nearestPoint(x: number, width: number, count: number): number;
+export declare function axisLabelIndexes(count: number, max?: number): number[];
+export declare function sparkPoints(values: readonly number[], width: number, height: number): LinePoint[];
+export type TrendDirection = 'up' | 'down' | 'same';
+export type TrendGood = 'up' | 'down' | 'none';
+export interface TrendDelta {
+    direction: TrendDirection;
+    diff: number;
+    percent: number | null;
+}
+export declare function trendDelta(current: number, previous: number): TrendDelta;
+export declare function deltaTone(direction: TrendDirection, good: TrendGood): 'positive' | 'negative' | 'neutral';
+export declare function polar(cx: number, cy: number, r: number, a: number): {
+    x: number;
+    y: number;
+};
+export declare function arcPath(cx: number, cy: number, r: number, a0: number, a1: number): string;
+export declare function wedgePath(cx: number, cy: number, r: number, a0: number, a1: number): string;
+export declare function dayNumber(day: string): number;
+export declare const dayString: (ms: number) => string;
+export declare const weekdayOf: (day: string) => number;
+export declare function dayRange(from: string, to: string): string[];
+export declare const CALENDAR_DAYS_MAX = 371;
+export declare const CALENDAR_LEVELS = 5;
+export declare function calendarLevel(count: number, max: number): number;
+export interface CalendarCell {
+    day: string;
+    count: number;
+    week: number;
+    weekday: number;
+    level: number;
+}
+export interface CalendarGrid {
+    cells: CalendarCell[];
+    weeks: number;
+    months: Array<{
+        month: string;
+        week: number;
+    }>;
+    max: number;
+    total: number;
+}
+export declare function calendarGrid(days: ReadonlyArray<{
+    day: string;
+    count: number;
+}>): CalendarGrid;
+export declare const CALENDAR_CELL: {
+    readonly min: 4;
+    readonly max: 16;
+    readonly compactMax: 12;
+};
+export declare const CALENDAR_WEEKDAYS = 28;
+export declare const CALENDAR_MONTH_ROOM = 26;
+export interface CalendarCellSize {
+    cell: number;
+    gap: number;
+    weekdays: boolean;
+}
+export declare function calendarCellSize(width: number, weeks: number, max?: number, scale?: number): CalendarCellSize;
+export declare const calendarWeekdaysWidth: (scale?: number) => number;
+export declare const calendarMonthRoom: (scale?: number) => number;
+export declare function calendarMonthLabels<M extends {
+    week: number;
+}>(months: readonly M[], pitch: number, scale?: number): M[];
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare function squarify(values: readonly number[], rect: Rect): Rect[];
+export interface TreemapNode {
+    key: string;
+    label: string;
+    value: number;
+    slot: ChartColor;
+    selectable?: boolean;
+    children?: TreemapNode[];
+}
+export interface TreemapTile {
+    node: TreemapNode;
+    parent: TreemapNode | null;
+    rect: Rect;
+    label: boolean;
+}
+export declare const TREEMAP_LABEL_MIN: {
+    w: number;
+    h: number;
+};
+export declare const TREEMAP_HEADER = 16;
+export declare const TREEMAP_GAP = 2;
+export declare function treemapLayout(nodes: readonly TreemapNode[], width: number, height: number, scale?: number): TreemapTile[];
+export declare const childOpacity: (index: number) => number;
+export interface FunnelRow<T extends {
+    value: number;
+}> {
+    step: T;
+    width: number;
+    ofFirst: number;
+    drop: number | null;
+}
+export declare function funnelRows<T extends {
+    value: number;
+}>(steps: readonly T[]): FunnelRow<T>[];
+export type GaugeVariant = 'half' | 'ring';
+export declare const GAUGE_SHAPE: {
+    readonly half: {
+        readonly width: 120;
+        readonly height: 68;
+        readonly cx: 60;
+        readonly cy: 62;
+        readonly r: 50;
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly ring: {
+        readonly width: 100;
+        readonly height: 100;
+        readonly cx: 50;
+        readonly cy: 50;
+        readonly r: 40;
+        readonly from: 0;
+        readonly to: number;
+    };
+};
+export declare const GAUGE_STROKE = 12;
+export declare function gaugeSweep(variant: GaugeVariant, share: number): {
+    a0: number;
+    a1: number;
+    end: number;
+};
+export declare const PIE_RADIUS = 48;
+export declare const PIE_LABEL_RADIUS = 0.62;
+export declare const PIE_LABEL_MIN_SHARE = 8;
+export interface PieWedge {
+    slice: ChartSlice;
+    a0: number;
+    a1: number;
+    share: number;
+    label: {
+        x: number;
+        y: number;
+    } | null;
+}
+export declare function pieWedges(slices: ChartSlice[], radius?: number, centre?: number): PieWedge[];

package/dist/types/components/Charts/index.d.ts

@@ -0,0 +1,32 @@
+export { Chart, type ChartProps } from './Chart';
+export { ChartView, type ChartViewProps } from './ChartView';
+export { ChartIcon } from './ChartIcon';
+export { chartOfData, chartsFor, countSeries, toChart, type ChartData, type ChartDataWords, type ChartKind, type ChartPeriodCount, type ChartStepCount, type ChartValueCount } from './chartData';
+export { BarList, type BarListProps } from './BarList';
+export { CalendarHeatmap, weekdayNames, type CalendarDay, type CalendarHeatmapProps } from './CalendarHeatmap';
+export { ChartTable, type ChartTableProps } from './ChartTable';
+export { ColumnChart, type ColumnChartProps } from './ColumnChart';
+export { Donut, type DonutProps } from './Donut';
+export { Funnel, type FunnelProps } from './Funnel';
+export { Gauge, type GaugeProps } from './Gauge';
+export { Legend, type LegendProps } from './Legend';
+export { LineChart, type LineChartProps } from './LineChart';
+export { NumberTrend, type NumberTrendPoint, type NumberTrendProps } from './NumberTrend';
+export { CALENDAR_DAYS_MAX, calendarGrid, dayRange, deltaTone, trendDelta, type ColumnMode, type GaugeVariant, type TrendDelta, type TrendDirection, type TrendGood } from './geometry';
+export { Progress, type ProgressProps } from './Progress';
+export { StackedBar, type StackedBarProps } from './StackedBar';
+export { Treemap, type TreemapProps } from './Treemap';
+export { squarify, treemapLayout, type Rect, type TreemapNode, type TreemapTile } from './geometry';
+export { ChartImageMenu, type ChartImageMenuProps } from './ChartImageMenu';
+export { AnchoredMenu, type AnchoredMenuItem, type AnchoredMenuProps } from './AnchoredMenu';
+export { layerOrigin, placeMenu, type MenuPlacement, type MenuPlacementOptions } from './menuPlacement';
+export { CHART_IMAGE_PALETTE, chartImageBlob, chartImageFileName, paintChartImage, type ChartImage, type ChartImageCanvas, type ChartImageChart, type ChartImageContext, type ChartImageProgressRow } from './chartImage';
+export { DEFAULT_CHART_LABELS, type ChartLabels } from './labels';
+export { CHART_GENERATED, CHART_HEAT, heatColor, CHART_INK, CHART_LEVELS_DEFAULT, CHART_PALETTE, CHART_PICKED_COLOURS, chartColor, colorCss, colorHex, hexToOklab, inkOn, isChartLevels, levelColor, luminance, oklabDistance, oklchToHex, slotColor, slotHex, slotInk, type ChartScheme } from './palette';
+export { PIE_LABEL_MIN_SHARE } from './geometry';
+export { formatPercent } from './parts';
+export { TooltipBody, hitRect, hitRects, useChartPointer, type ChartPointer, type ChartPointerOptions } from './ChartTooltip';
+export { HOLE, POINTER_GAP, angleOf, bandAt, placeAtPointer, rectAt, sliceAt, spanAt, type ChartRect, type PointerPlacement } from './pointer';
+export { CALENDAR_CELL, calendarCellSize, calendarMonthLabels, type CalendarCellSize } from './geometry';
+export { useBoxSize, useBoxWidth, type BoxSize } from './useBoxSize';
+export type { ChartCategoricalSlot, ChartColor, ChartLevels, ChartProgressColor, ChartDatum, ChartFormatProps, ChartLinkComponent, ChartLinkProps, ChartSelectProps, ChartSeries, ChartSlice, ChartSlot, ChartStatusSlot } from './types';

package/dist/types/components/Charts/labels.d.ts

@@ -0,0 +1,46 @@
+export declare const DEFAULT_CHART_LABELS: {
+    legend: string;
+    total: string;
+    empty: string;
+    count: string;
+    rest: string;
+    kinds: {
+        donut: string;
+        pie: string;
+        bars: string;
+        stacked: string;
+        treemap: string;
+        columns: string;
+        line: string;
+        area: string;
+        grouped: string;
+        calendar: string;
+        bar: string;
+        gauge: string;
+        ring: string;
+        funnel: string;
+        number: string;
+        numberTrend: string;
+    };
+    chartChoice: string;
+    imageMenu: string;
+    imageDownload: string;
+    imageCopy: string;
+    imageShare: string;
+    imageCopied: string;
+    imageFailed: string;
+    vsPrevious: string;
+    deltaUp: string;
+    deltaDown: string;
+    deltaSame: string;
+    deltaNew: string;
+    ofTotal: (value: string, total: string) => string;
+    shareOf: (share: string, total: string) => string;
+    moreValues: (n: string) => string;
+    less: string;
+    more: string;
+    busiest: string;
+    funnelOfFirst: string;
+    funnelDrop: string;
+};
+export type ChartLabels = typeof DEFAULT_CHART_LABELS;

package/dist/types/components/Charts/menuPlacement.d.ts

@@ -0,0 +1,25 @@
+import type { ChartRect } from './pointer';
+export interface MenuPlacement {
+    left: number;
+    top: number;
+    side: 'below' | 'above';
+}
+export interface MenuPlacementOptions {
+    align?: 'start' | 'end';
+    offset?: number;
+    margin?: number;
+}
+export declare function placeMenu(anchor: ChartRect, box: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, { align, offset, margin }?: MenuPlacementOptions): MenuPlacement;
+export declare function layerOrigin(rect: {
+    left: number;
+    top: number;
+}, left: number, top: number): {
+    x: number;
+    y: number;
+};

package/dist/types/components/Charts/palette.d.ts

@@ -0,0 +1,81 @@
+import type { ChartColor, ChartLevels, ChartProgressColor, ChartSlot } from './types';
+export type ChartScheme = 'light' | 'dark';
+export declare const CHART_PICKED_COLOURS = 10;
+export declare const CHART_PALETTE: {
+    light: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        rest: string;
+        positive: string;
+        warning: string;
+        negative: string;
+        info: string;
+        neutral: string;
+    };
+    dark: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        rest: string;
+        positive: string;
+        warning: string;
+        negative: string;
+        info: string;
+        neutral: string;
+    };
+};
+export declare const CHART_GENERATED: {
+    readonly light: {
+        readonly lightness: readonly [0.46, 0.54, 0.62, 0.7, 0.78];
+        readonly chroma: readonly [0.09, 0.13, 0.17];
+        readonly hueStep: 8;
+        readonly background: "#ffffff";
+    };
+    readonly dark: {
+        readonly lightness: readonly [0.58, 0.66, 0.74, 0.82, 0.9];
+        readonly chroma: readonly [0.09, 0.13, 0.17];
+        readonly hueStep: 8;
+        readonly background: "#1f1f1f";
+    };
+};
+type Lab = readonly [number, number, number];
+export declare const oklchToHex: (l: number, c: number, h: number) => string;
+export declare function hexToOklab(hex: string): Lab;
+export declare const oklabDistance: (p: Lab, q: Lab) => number;
+export declare const generatedCandidates: (scheme: ChartScheme) => string[];
+export declare function chartColor(index: number, scheme: ChartScheme): string;
+export declare const slotHex: (slot: ChartSlot, scheme: ChartScheme) => string;
+export declare function slotColor(slot: ChartSlot): string;
+export declare const CHART_LEVELS_DEFAULT: ChartLevels;
+export declare const isChartLevels: (c: ChartProgressColor | undefined) => c is ChartLevels;
+export declare function levelColor(color: ChartProgressColor, share: number): ChartColor;
+export declare const colorCss: (c: ChartColor) => string;
+export declare const colorHex: (c: ChartColor, scheme: ChartScheme) => string;
+export declare const CHART_HEAT: {
+    readonly light: readonly ["#e8eff9", "#bcd3f2", "#7faee9", "#4081d2", "#155aa7"];
+    readonly dark: readonly ["#242930", "#2c4462", "#39659b", "#4f8bd6", "#82baff"];
+};
+export declare const heatColor: (level: number) => string;
+export declare const CHART_INK: {
+    readonly dark: "#0f0f0f";
+    readonly light: "#ffffff";
+};
+export declare function luminance(hex: string): number;
+export declare function inkOn(hex: string): string;
+export declare function slotInk(slot: ChartColor): string;
+export {};

package/dist/types/components/Charts/parts.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+import { type ChartLabels } from './labels';
+import type { ChartFormatProps } from './types';
+export { colorCss } from './palette';
+export declare const chartClass: (block: string, compact?: boolean) => string;
+export declare function Titled({ title, children }: {
+    title?: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function formatPercent(p: number): string;
+export declare const funnelDropText: (drop: number) => string;
+export declare function useChartFormat({ locale, format, labels }: ChartFormatProps): {
+    nf: (n: number) => string;
+    L: ChartLabels;
+};
+export declare function ChartEmpty({ ariaLabel, text, compact }: {
+    ariaLabel: string;
+    text: string;
+    compact: boolean;
+}): import("react").JSX.Element;
+export declare function roveIndex(key: string, index: number | null, count: number, steps?: Partial<Record<'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown', number>>): number | null;
+export declare function roveControls(key: string, index: number | null, count: number, steps?: Partial<Record<'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown', number>>, has?: (index: number) => boolean): number | null;
+export declare function ChartLive({ text }: {
+    text: string;
+}): import("react").JSX.Element;

package/dist/types/components/Charts/pointer.d.ts

@@ -0,0 +1,41 @@
+export interface ChartRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function bandAt(x: number, width: number, count: number): number | null;
+export declare function spanAt(v: number, spans: ReadonlyArray<{
+    start: number;
+    end: number;
+}>): number | null;
+export declare function rectAt(x: number, y: number, rects: ReadonlyArray<ChartRect | null>): number | null;
+export declare function angleOf(dx: number, dy: number): number;
+export declare const HOLE = -1;
+export declare function sliceAt(dx: number, dy: number, outer: number, inner: number, arcs: ReadonlyArray<{
+    a0: number;
+    a1: number;
+}>): number | null;
+export interface PointerPlacement {
+    left: number;
+    top: number;
+    x: 'right' | 'left';
+    y: 'below' | 'above';
+}
+export declare const POINTER_GAP: {
+    readonly x: 12;
+    readonly y: 4;
+};
+export declare function placeAtPointer(point: {
+    x: number;
+    y: number;
+}, box: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, gap?: {
+    x: number;
+    y: number;
+}, margin?: number): PointerPlacement;

package/dist/types/components/Charts/types.d.ts

@@ -0,0 +1,51 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { ChartLabels } from './labels';
+export type ChartStatusSlot = 'positive' | 'warning' | 'negative' | 'info' | 'neutral';
+export type ChartCategoricalSlot = number;
+export type ChartSlot = ChartCategoricalSlot | 'rest' | ChartStatusSlot;
+export type ChartColor = ChartSlot | `#${string}`;
+export interface ChartLevels {
+    bands: Array<{
+        below: number;
+        color: ChartColor;
+    }>;
+    above: ChartColor;
+}
+export type ChartProgressColor = ChartColor | ChartLevels;
+export interface ChartSeries {
+    key: string;
+    label: string;
+    slot: ChartColor;
+}
+export interface ChartDatum {
+    key?: string;
+    label: string;
+    fullLabel?: string;
+    values: Record<string, number>;
+    selectable?: boolean;
+    slot?: ChartColor;
+    href?: string;
+}
+export interface ChartSlice {
+    key: string;
+    label: string;
+    value: number;
+    slot: ChartColor;
+    selectable?: boolean;
+}
+export interface ChartLinkProps {
+    href: string;
+    className?: string;
+    title?: string;
+    children: ReactNode;
+}
+export type ChartLinkComponent = ComponentType<ChartLinkProps>;
+export interface ChartFormatProps {
+    locale?: string;
+    format?: (n: number) => string;
+    labels?: Partial<ChartLabels>;
+}
+export interface ChartSelectProps<T> {
+    onSelect?: (item: T) => void;
+    selected?: string | null;
+}

package/dist/types/components/Charts/ui.d.ts

@@ -0,0 +1,3 @@
+export { Button } from '../Button';
+export { useUIPortalContainer } from '../UIProvider/UIPortalContext';
+export { computeTooltipPosition } from '../../core/logic';

package/dist/types/components/Charts/useBoxSize.d.ts

@@ -0,0 +1,6 @@
+export interface BoxSize {
+    width: number;
+    height: number;
+}
+export declare function useBoxSize(): [(el: HTMLElement | null) => void, BoxSize];
+export declare function useBoxWidth(): [(el: HTMLElement | null) => void, number];

package/dist/types/components/Charts/useLegendFit.d.ts

@@ -0,0 +1 @@
+export declare function useLegendFit(count: number, enabled: boolean): [(el: HTMLElement | null) => void, number, number];

package/dist/types/components/Charts/useUiScale.d.ts

@@ -0,0 +1 @@
+export declare function useUiScale(): [(el: HTMLElement | null) => void, number];

package/dist/types/{shared-web-ui/src → components}/Checkbox/Checkbox.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { CheckboxProps, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
+import { CheckboxProps, FieldHandle } from '../../core/types';
 declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<FieldHandle>>;
 export default Checkbox;

package/dist/types/{shared-web-ui/src → components}/Checkbox/CheckboxGroup.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { CheckboxGroupProps } from '../../../published/dcs-ui/src/publicTypes';
+import { CheckboxGroupProps } from '../../core/types';
 declare const CheckboxGroup: React.FC<CheckboxGroupProps>;
 export default CheckboxGroup;

package/dist/types/{shared-web-ui/src → components}/Checkbox/CheckboxGroupContext.d.ts

@@ -1,3 +1,3 @@
-import { CheckboxGroupContextValue } from '../../../published/dcs-ui/src/publicTypes';
+import { CheckboxGroupContextValue } from '../../core/types';
 export declare const CheckboxGroupCtx: import("react").Context<CheckboxGroupContextValue | null>;
 export declare function useCheckboxGroup(): CheckboxGroupContextValue | null;

package/dist/types/{shared-web-ui/src → components}/Checkbox/index.d.ts

@@ -1,3 +1,3 @@
 export { default as Checkbox } from './Checkbox';
 export { default as CheckboxGroup } from './CheckboxGroup';
-export type { CheckboxProps, CheckboxGroupProps, CheckboxVariant, CheckboxSize, CheckboxLabelPosition, CheckboxColor, CheckboxGroupContextValue, } from '../../../published/dcs-ui/src/publicTypes';
+export type { CheckboxProps, CheckboxGroupProps, CheckboxVariant, CheckboxSize, CheckboxLabelPosition, CheckboxColor, CheckboxGroupContextValue, } from '../../core/types';

package/dist/types/{shared-web-ui/src → components}/ChipInput/ChipInput.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ChipInputProps, FieldHandle } from '../../../published/dcs-ui/src/publicTypes';
+import type { ChipInputProps, FieldHandle } from '../../core/types';
 declare const ChipInput: React.ForwardRefExoticComponent<ChipInputProps & React.RefAttributes<FieldHandle>>;
 export { ChipInput };
 export default ChipInput;

package/dist/types/{shared-web-ui/src → components}/ChipInput/index.d.ts

@@ -1,5 +1,5 @@
 export { ChipInput } from './ChipInput';
 export { default } from './ChipInput';
 export { useChipSuggestions } from './useChipSuggestions';
-export { parseFormat, resolveFormat, extractPlaceholders, validateFormat, } from '../../../published/dcs-ui/src/publicLogic';
-export type { ChipInputProps, ChipInputSize, ChipInputLayout, ChipKey, ChipSource, ChipSources, ChipSuggestionItem, GroupedSuggestions, ParsedSegment, ResolveOptions, ExtractedPlaceholder, FormatValidationResult, UseChipSuggestionsOptions, UseChipSuggestionsReturn, } from '../../../published/dcs-ui/src/publicTypes';
+export { parseFormat, resolveFormat, extractPlaceholders, validateFormat, } from '../../core/logic';
+export type { ChipInputProps, ChipInputSize, ChipInputLayout, ChipKey, ChipSource, ChipSources, ChipSuggestionItem, GroupedSuggestions, ParsedSegment, ResolveOptions, ExtractedPlaceholder, FormatValidationResult, UseChipSuggestionsOptions, UseChipSuggestionsReturn, } from '../../core/types';