@oslokommune/punkt-react 16.9.0 → 16.9.1

package/CHANGELOG.md

@@ -5,6 +5,24 @@ og skriver commits ca etter [Conventional Commits](https://conventionalcommits.o
 
 ---
 
+## [16.9.1](https://github.com/oslokommune/punkt/compare/16.9.0...16.9.1) (2026-04-22)
+
+### ⚠ BREAKING CHANGES
+Ingen
+
+### Features
+Ingen
+
+### Bug Fixes
+* Fikser opp i bygging og DTS-generering (#3434). 
+
+
+### Chores
+Ingen
+
+---
+
+
 ## [16.9.0](https://github.com/oslokommune/punkt/compare/16.8.3...16.9.0) (2026-04-21)
 
 ### ⚠ BREAKING CHANGES

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AnchorHTMLAttributes } from 'react';
-import { Booleanish } from '../../../../../shared-types';
+import { Booleanish } from './shared-types';
 import { ButtonHTMLAttributes } from 'react';
 import { ChangeEvent } from 'react';
 import { ChangeEventHandler } from 'react';
@@ -9,13 +9,13 @@ import { FocusEvent as FocusEvent_2 } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { HTMLAttributes } from 'react';
 import { HTMLProps } from 'react';
-import { IDatepickerStrings } from '../../../../../shared-types/datepicker';
+import { IDatepickerStrings } from './shared-types/datepicker';
 import { InputHTMLAttributes } from 'react';
-import { IPktComboboxOption } from '../../../../../shared-types/combobox';
+import { IPktComboboxOption } from './shared-types/combobox';
 import { IPktConsent as IPktConsent_2 } from '@oslokommune/punkt-elements';
 import { IPktHeading as IPktHeading_2 } from '@oslokommune/punkt-elements';
 import { IPktLoader as IPktLoader_2 } from '@oslokommune/punkt-elements';
-import { ITimepickerStrings } from '../../../../../shared-types/timepicker';
+import { ITimepickerStrings } from './shared-types/timepicker';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import { LegacyRef } from 'react';
 import { LinkHTMLAttributes } from 'react';
@@ -27,26 +27,26 @@ import { RefAttributes } from 'react';
 import { RefObject } from 'react';
 import { SelectHTMLAttributes } from 'react';
 import { SyntheticEvent } from 'react';
-import { TAccordionSkin } from '../../../../../shared-types';
-import { TAlertRole } from '../../../../../shared-types';
-import { TAlertSkin } from '../../../../../shared-types';
-import { TAriaLive } from '../../../../../shared-types';
-import { TCardSkin } from '../../../../../shared-types';
+import { TAccordionSkin } from './shared-types';
+import { TAlertRole } from './shared-types';
+import { TAlertSkin } from './shared-types';
+import { TAriaLive } from './shared-types';
+import { TCardSkin } from './shared-types';
 import { TextareaHTMLAttributes } from 'react';
-import { THeaderMenu } from '../../../../../shared-types';
-import { THeaderPosition } from '../../../../../shared-types';
-import { THeaderScrollBehavior } from '../../../../../shared-types';
-import { TLayout } from '../../../../../shared-types';
-import { TLogOutButtonPlacement } from '../../../../../shared-types';
-import { TMessageboxSkin } from '../../../../../shared-types';
-import { TPktComboboxDisplayValue } from '../../../../../shared-types/combobox';
-import { TPktComboboxTagPlacement } from '../../../../../shared-types/combobox';
-import { TProgressbarRole } from '../../../../../shared-types';
-import { TProgressbarSkin } from '../../../../../shared-types';
-import { TProgressbarStatusPlacement } from '../../../../../shared-types';
-import { TProgressbarStatusType } from '../../../../../shared-types';
-import { TProgressbarTitlePosition } from '../../../../../shared-types';
-import { TSlotMenuVariant } from '../../../../../shared-types';
+import { THeaderMenu } from './shared-types';
+import { THeaderPosition } from './shared-types';
+import { THeaderScrollBehavior } from './shared-types';
+import { TLayout } from './shared-types';
+import { TLogOutButtonPlacement } from './shared-types';
+import { TMessageboxSkin } from './shared-types';
+import { TPktComboboxDisplayValue } from './shared-types/combobox';
+import { TPktComboboxTagPlacement } from './shared-types/combobox';
+import { TProgressbarRole } from './shared-types';
+import { TProgressbarSkin } from './shared-types';
+import { TProgressbarStatusPlacement } from './shared-types';
+import { TProgressbarStatusType } from './shared-types';
+import { TProgressbarTitlePosition } from './shared-types';
+import { TSlotMenuVariant } from './shared-types';
 
 declare interface BasePktTagProps {
     skin?: 'blue' | 'blue-light' | 'blue-dark' | 'green' | 'red' | 'beige' | 'yellow' | 'grey' | 'gray';

package/dist/shared-types/aria.d.ts

@@ -0,0 +1,65 @@
+/**
+ * aria.ts
+ *
+ * Type definitions for ARIA attributes and roles.
+ * These follow the WAI-ARIA specification and are used across all Punkt components.
+ */
+export type TAriaBoolean = boolean | 'true' | 'false';
+export type TAriaBooleanMixed = TAriaBoolean | 'mixed';
+export type TAriaCurrent = TAriaBoolean | 'page' | 'step' | 'location' | 'date' | 'time';
+export type TAriaHasPopup = TAriaBoolean | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';
+export type TAriaInvalid = TAriaBoolean | 'grammar' | 'spelling';
+export type TAriaLive = 'off' | 'polite' | 'assertive';
+export type TAriaRelevant = 'additions' | 'removals' | 'text' | 'all';
+export type TAriaSort = 'none' | 'ascending' | 'descending' | 'other';
+export type TAriaAutoComplete = 'none' | 'inline' | 'list' | 'both';
+export type TAriaOrientation = 'horizontal' | 'vertical';
+export interface IAriaAttributes {
+    'aria-activedescendant'?: string;
+    'aria-controls'?: string;
+    'aria-describedby'?: string;
+    'aria-details'?: string;
+    'aria-errormessage'?: string;
+    'aria-flowto'?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-owns'?: string;
+    'aria-roledescription'?: string;
+    'aria-autocomplete'?: TAriaAutoComplete;
+    'aria-checked'?: TAriaBooleanMixed;
+    'aria-current'?: TAriaCurrent;
+    'aria-disabled'?: TAriaBoolean;
+    'aria-expanded'?: TAriaBoolean;
+    'aria-haspopup'?: TAriaHasPopup;
+    'aria-hidden'?: TAriaBoolean;
+    'aria-invalid'?: TAriaInvalid;
+    'aria-keyshortcuts'?: string;
+    'aria-level'?: number;
+    'aria-modal'?: TAriaBoolean;
+    'aria-multiline'?: TAriaBoolean;
+    'aria-multiselectable'?: TAriaBoolean;
+    'aria-orientation'?: TAriaOrientation;
+    'aria-placeholder'?: string;
+    'aria-pressed'?: TAriaBooleanMixed;
+    'aria-readonly'?: TAriaBoolean;
+    'aria-required'?: TAriaBoolean;
+    'aria-selected'?: TAriaBoolean;
+    'aria-sort'?: TAriaSort;
+    'aria-atomic'?: TAriaBoolean;
+    'aria-busy'?: TAriaBoolean;
+    'aria-live'?: TAriaLive;
+    'aria-relevant'?: TAriaRelevant | string;
+    'aria-colcount'?: number;
+    'aria-colindex'?: number;
+    'aria-colspan'?: number;
+    'aria-rowcount'?: number;
+    'aria-rowindex'?: number;
+    'aria-rowspan'?: number;
+    'aria-posinset'?: number;
+    'aria-setsize'?: number;
+    'aria-valuemax'?: number;
+    'aria-valuemin'?: number;
+    'aria-valuenow'?: number;
+    'aria-valuetext'?: string;
+}
+export type TAlertRole = 'alert' | 'status';

package/dist/shared-types/booleanish.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Booleanish type that accepts boolean or string "true"/"false"
+ * This allows attributes to be set as strings in HTML
+ */
+export type Booleanish = boolean | 'true' | 'false';
+/**
+ * Converter for booleanish attributes
+ * Converts string "true"/"false" to boolean values
+ */
+export declare const booleanishConverter: {
+    fromAttribute(value: string | boolean | null): boolean;
+    toAttribute(value: boolean): string | null;
+};

package/dist/shared-types/calendar.d.ts

@@ -0,0 +1,41 @@
+/**
+ * calendar.ts
+ *
+ * Type definitions for the calendar component.
+ * Used by both Elements and React calendar implementations
+ * and by the shared calendar helper functions.
+ */
+export interface IDateConstraints {
+    earliest: string | null;
+    latest: string | null;
+    excludedates: Date[];
+    excludeweekdays: string[];
+}
+export interface ICalendarGridDimensions {
+    firstDayOfMonth: Date;
+    lastDayOfMonth: Date;
+    startingDay: number;
+    numDays: number;
+    numRows: number;
+    numDaysPrevMonth: number;
+    initialWeek: number;
+}
+export interface IGridCellPosition {
+    rowIndex: number;
+    colIndex: number;
+}
+export type TDateRangeMap = {
+    [key: string]: boolean;
+};
+export interface ISelectionState {
+    selected: string[];
+    _selected: Date[];
+    inRange: TDateRangeMap;
+}
+export interface ISelectionOptions {
+    multiple: boolean;
+    maxMultiple: number;
+    range: boolean;
+    excludedates: Date[];
+    excludeweekdays: string[];
+}

package/dist/shared-types/combobox.d.ts

@@ -0,0 +1,34 @@
+/**
+ * combobox.ts
+ *
+ * Type definitions for the combobox and listbox components.
+ * Used by both Elements and React implementations
+ * and by the shared combobox helper functions.
+ */
+/**
+ * Tag skin colors available for combobox option tags.
+ * Matches the TTagSkin values from the tag component.
+ */
+export type TPktComboboxTagSkin = 'blue' | 'blue-dark' | 'blue-light' | 'green' | 'red' | 'yellow' | 'beige' | 'gray' | 'grey';
+/**
+ * Represents a single option in a combobox or listbox.
+ */
+export interface IPktComboboxOption {
+    description?: string;
+    disabled?: boolean;
+    fulltext?: string;
+    label?: string;
+    prefix?: string;
+    selected?: boolean;
+    tagSkinColor?: TPktComboboxTagSkin;
+    userAdded?: boolean;
+    value: string;
+}
+/**
+ * How the selected value is displayed in the combobox input.
+ */
+export type TPktComboboxDisplayValue = 'label' | 'value' | 'prefixAndValue';
+/**
+ * Placement of selected value tags in multiple selection mode.
+ */
+export type TPktComboboxTagPlacement = 'inside' | 'outside';

package/dist/shared-types/datepicker.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Internationalization strings for the datepicker component family.
+ * Shared between Elements and React packages.
+ */
+export interface IDatepickerStrings {
+    /** Calendar-related strings */
+    calendar?: {
+        /** Alt text for calendar button */
+        buttonAltText?: string;
+    };
+    /** Generic UI strings (used in range datepicker) */
+    generic?: {
+        /** Label for range start input */
+        from?: string;
+        /** Label for range end input */
+        to?: string;
+    };
+    /** Form validation messages */
+    forms?: {
+        messages?: {
+            /** Error message when date is before minimum */
+            rangeUnderflow?: string;
+            /** Error message when date is after maximum */
+            rangeOverflow?: string;
+            /** Error message for invalid date format */
+            badInput?: string;
+            /** Error message when required field is empty */
+            valueMissing?: string;
+        };
+    };
+    /** Date-related strings */
+    dates?: {
+        /** Month label */
+        month?: string;
+        /** Year label */
+        year?: string;
+    };
+}
+/**
+ * Default strings for single/multiple datepicker
+ */
+export declare const defaultSingleStrings: IDatepickerStrings;
+/**
+ * Default strings for range datepicker
+ */
+export declare const defaultRangeStrings: IDatepickerStrings;

package/dist/shared-types/form.d.ts

@@ -0,0 +1,16 @@
+/**
+ * form.ts
+ *
+ * Type definitions for HTML form elements and controls.
+ * These follow HTML standards for form element types.
+ */
+/**
+ * HTML button type attribute values
+ * Used for <button type="..."> and similar elements
+ */
+export type THTMLButtonType = 'button' | 'submit' | 'reset';
+/**
+ * Selection mode for form controls
+ * Used in components that support single, multiple, or range selection
+ */
+export type TSelectionMode = 'single' | 'multiple' | 'range';

package/dist/shared-types/header.d.ts

@@ -0,0 +1,88 @@
+/**
+ * header.ts
+ *
+ * Type definitions for header-related domain models.
+ * These represent user, organization, and menu item data structures.
+ */
+/**
+ * User object containing information about the logged-in user
+ */
+export interface User {
+    /** Full name of the user */
+    name: string;
+    /** Short name or initials (deprecated) */
+    shortname?: string;
+    /** Last login timestamp (ISO string or Date) */
+    lastLoggedIn?: Date | string;
+}
+/**
+ * Representation object containing information about the organization/entity being represented
+ */
+export interface Representing {
+    /** Name of the organization or entity */
+    name: string;
+    /** Short name or initials (deprecated) */
+    shortname?: string;
+    /** Organization number */
+    orgNumber?: string | number;
+}
+/**
+ * Menu item in the user menu
+ * The iconName will be typed as PktIconName in package-specific implementations
+ */
+export interface UserMenuItem<IconType = string> {
+    /** Icon name to display */
+    iconName?: IconType;
+    /** Text for the menu item */
+    title: string;
+    /** Link URL or click handler function */
+    target: string | (() => void);
+}
+/**
+ * Internal type for rendering links/buttons (supports both href and onClick)
+ * Base interface for discriminated union
+ */
+export interface InternalMenuItemBase<IconType = string> {
+    title: string;
+    iconName?: IconType;
+}
+/**
+ * Internal menu item that is a link
+ */
+export interface InternalMenuLink<IconType = string> extends InternalMenuItemBase<IconType> {
+    href: string;
+}
+/**
+ * Internal menu item that is a button
+ */
+export interface InternalMenuButton<IconType = string> extends InternalMenuItemBase<IconType> {
+    onClick: () => void;
+}
+/**
+ * Union type for internal menu items (discriminated by href vs onClick)
+ */
+export type TInternalMenuItem<IconType = string> = InternalMenuLink<IconType> | InternalMenuButton<IconType>;
+/**
+ * Helper to convert UserMenuItem (with target) to internal format
+ */
+export declare const convertUserMenuItem: <IconType = string>(item: UserMenuItem<IconType>) => TInternalMenuItem<IconType>;
+/**
+ * Variant for the slot menu button in tablet/mobile mode
+ */
+export type TSlotMenuVariant = 'icon-only' | 'icon-right';
+/**
+ * Type for which menu is currently open in the header
+ */
+export type THeaderMenu = 'none' | 'slot' | 'search' | 'user';
+/**
+ * Placement options for the logout button
+ */
+export type TLogOutButtonPlacement = 'userMenu' | 'header' | 'both' | 'none';
+/**
+ * Position options for the header
+ */
+export type THeaderPosition = 'fixed' | 'relative';
+/**
+ * Scroll behavior options for the header
+ */
+export type THeaderScrollBehavior = 'hide' | 'none';

package/dist/shared-types/heading.d.ts

@@ -0,0 +1,9 @@
+/**
+ * heading.ts
+ *
+ * Type definitions for heading-related types.
+ * These represent HTML heading semantics (h1-h6) and typography scales.
+ */
+export type THeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type THeadingSize = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
+export type THeadingWeight = 'light' | 'regular' | 'medium' | 'bold';

package/dist/shared-types/index.d.ts

@@ -0,0 +1,17 @@
+export type { Booleanish } from './booleanish';
+export { booleanishConverter } from './booleanish';
+export type { TAriaBoolean, TAriaBooleanMixed, TAriaCurrent, TAriaHasPopup, TAriaInvalid, TAriaLive, TAriaRelevant, TAriaSort, TAriaAutoComplete, TAriaOrientation, IAriaAttributes, TAlertRole, } from './aria';
+export type { THeadingLevel, THeadingSize, THeadingWeight } from './heading';
+export type { User, Representing, UserMenuItem, InternalMenuItemBase, InternalMenuLink, InternalMenuButton, TInternalMenuItem, TSlotMenuVariant, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, } from './header';
+export { convertUserMenuItem } from './header';
+export type { TLayout, TVerticalPosition, THorizontalPosition, TPosition, TPositionWithCenter, } from './layout';
+export type { THTMLButtonType, TSelectionMode } from './form';
+export type { TSize3, TSize5, TSize7 } from './size';
+export type { TAlertSkin, TMessageboxSkin, TAccordionSkin, TCardSkin } from './skin';
+export type { IDateConstraints, ICalendarGridDimensions, IGridCellPosition, TDateRangeMap, ISelectionState, ISelectionOptions, } from './calendar';
+export type { IDatepickerStrings } from './datepicker';
+export { defaultSingleStrings, defaultRangeStrings } from './datepicker';
+export type { ITimepickerStrings } from './timepicker';
+export { defaultTimepickerStrings } from './timepicker';
+export type { TProgressbarRole, TProgressbarSkin, TProgressbarStatusPlacement, TProgressbarStatusType, TProgressbarTitlePosition, } from './progressbar';
+export type { IPktComboboxOption, TPktComboboxTagSkin, TPktComboboxDisplayValue, TPktComboboxTagPlacement, } from './combobox';

package/dist/shared-types/layout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * layout.ts
+ *
+ * Type definitions for layout and positioning.
+ * These represent common layout patterns used across components.
+ */
+/**
+ * Layout direction - vertical or horizontal orientation
+ */
+export type TLayout = 'vertical' | 'horizontal';
+/**
+ * Generic positioning type for top/bottom placement
+ */
+export type TVerticalPosition = 'top' | 'bottom';
+/**
+ * Generic positioning type for left/right placement
+ */
+export type THorizontalPosition = 'left' | 'right';
+/**
+ * Generic positioning type for all four directions
+ */
+export type TPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Generic positioning including center
+ */
+export type TPositionWithCenter = TPosition | 'center';

package/dist/shared-types/progressbar.d.ts

@@ -0,0 +1,5 @@
+export type TProgressbarRole = 'progressbar' | 'meter';
+export type TProgressbarSkin = 'dark-blue' | 'light-blue' | 'green' | 'red';
+export type TProgressbarStatusPlacement = 'center' | 'left' | 'following';
+export type TProgressbarStatusType = 'none' | 'percentage' | 'fraction';
+export type TProgressbarTitlePosition = 'left' | 'center';

package/dist/shared-types/size.d.ts

@@ -0,0 +1,18 @@
+/**
+ * size.ts
+ *
+ * Type definitions for sizing scales.
+ * These represent common size scales used across the design system.
+ */
+/**
+ * Standard 3-level size scale
+ */
+export type TSize3 = 'small' | 'medium' | 'large';
+/**
+ * Extended 5-level size scale
+ */
+export type TSize5 = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
+/**
+ * Full 7-level size scale
+ */
+export type TSize7 = 'xxsmall' | 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';

package/dist/shared-types/skin.d.ts

@@ -0,0 +1,24 @@
+/**
+ * skin.ts
+ *
+ * Type definitions for component skin/color variants.
+ * Only includes skin types that are identical across packages.
+ * Component-specific skin types should remain in their respective component files.
+ */
+/**
+ * Alert component skin variants
+ * Used for semantic color coding of alerts (error, success, warning, info)
+ */
+export type TAlertSkin = 'error' | 'success' | 'warning' | 'info';
+/**
+ * Messagebox component skin variants
+ */
+export type TMessageboxSkin = 'beige' | 'blue' | 'red' | 'green';
+/**
+ * Accordion component skin variants
+ */
+export type TAccordionSkin = 'borderless' | 'outlined' | 'beige' | 'blue';
+/**
+ * Card component skin variants
+ */
+export type TCardSkin = 'outlined' | 'outlined-beige' | 'gray' | 'beige' | 'green' | 'blue';

package/dist/shared-types/timepicker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * timepicker.ts
+ *
+ * Type definitions for the timepicker component.
+ * Used by both Elements and React implementations.
+ */
+/**
+ * Translation strings for the timepicker component.
+ * Matches the shape of the `timepicker` key in no.json.
+ */
+export interface ITimepickerStrings {
+    hours: string;
+    minutes: string;
+    openPicker: string;
+    prevTime: string;
+    nextTime: string;
+    selectTime: string;
+}
+/** Default labels (Norwegian Bokmål), aligned with `packages/elements/src/translations/no.json`. */
+export declare const defaultTimepickerStrings: ITimepickerStrings;

package/dist/shared-utils/calendar/calendar-grid.d.ts

@@ -0,0 +1,16 @@
+import type { ICalendarGridDimensions } from '../../shared-types/calendar';
+export type { ICalendarGridDimensions, IGridCellPosition } from '../../shared-types/calendar';
+export declare const DAYS_PER_WEEK = 7;
+export declare const MONDAY_OFFSET = 6;
+/**
+ * Calculate the dimensions and structure of the calendar grid
+ */
+export declare function calculateCalendarDimensions(year: number, month: number): ICalendarGridDimensions;
+/**
+ * Determine what type of cell to render at a given position
+ */
+export declare function getCellType(rowIndex: number, colIndex: number, dayCounter: number, gridDimensions: ICalendarGridDimensions): 'prev-month' | 'current-month' | 'next-month';
+/**
+ * Get the day number to display for a given cell
+ */
+export declare function getDayNumber(cellType: 'prev-month' | 'current-month' | 'next-month', colIndex: number, dayCounter: number, gridDimensions: ICalendarGridDimensions): number;

package/dist/shared-utils/calendar/date-validation.d.ts

@@ -0,0 +1,22 @@
+import type { IDateConstraints } from '../../shared-types/calendar';
+export type { IDateConstraints } from '../../shared-types/calendar';
+/**
+ * Check if a date is excluded based on constraints
+ */
+export declare function isDateExcluded(date: Date, constraints: IDateConstraints): boolean;
+/**
+ * Check if a day should be disabled for selection
+ */
+export declare function isDayDisabled(date: Date, isSelected: boolean, constraints: IDateConstraints, options: {
+    multiple: boolean;
+    maxMultiple: number;
+    selectedCount: number;
+}): boolean;
+/**
+ * Check if navigation to previous month is allowed
+ */
+export declare function isPrevMonthAllowed(year: number, month: number, earliest: string | null): boolean;
+/**
+ * Check if navigation to next month is allowed
+ */
+export declare function isNextMonthAllowed(year: number, month: number, latest: string | null): boolean;

package/dist/shared-utils/calendar/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calendar Helper Exports
+ *
+ * This module re-exports all calendar helper functions and types
+ * to provide a single import point for calendar-related utilities.
+ */
+export { isDateExcluded, isDayDisabled, isPrevMonthAllowed, isNextMonthAllowed, type IDateConstraints, } from './date-validation';
+export { DAYS_PER_WEEK, MONDAY_OFFSET, calculateCalendarDimensions, getCellType, getDayNumber, type ICalendarGridDimensions, type IGridCellPosition, } from './calendar-grid';
+export { convertSelectedToDates, updateRangeMap, isRangeAllowed, addToSelection, removeFromSelection, toggleSelection, handleRangeSelection, type TDateRangeMap, type ISelectionState, type ISelectionOptions, } from './selection-manager';
+export { KEY_DIRECTION_MAP, shouldIgnoreKeyboardEvent, findNextSelectableDate, getKeyDirection, } from './keyboard-navigation';

package/dist/shared-utils/calendar/keyboard-navigation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Keyboard navigation helpers for calendar component
+ */
+export declare const KEY_DIRECTION_MAP: Record<string, number>;
+/**
+ * Check if a keyboard event should be ignored
+ */
+export declare function shouldIgnoreKeyboardEvent(target: HTMLElement): boolean;
+/**
+ * Find the next selectable date in a given direction
+ */
+export declare function findNextSelectableDate(startDate: Date, direction: number, querySelector: (selector: string) => Element | null): Date | null;
+/**
+ * Get the direction for a keyboard event
+ */
+export declare function getKeyDirection(key: string): number | null;

package/dist/shared-utils/calendar/selection-manager.d.ts

@@ -0,0 +1,30 @@
+import type { TDateRangeMap, ISelectionOptions } from '../../shared-types/calendar';
+export type { TDateRangeMap, ISelectionState, ISelectionOptions } from '../../shared-types/calendar';
+/**
+ * Convert selected string array to Date array
+ */
+export declare function convertSelectedToDates(selected: string | string[]): Date[];
+/**
+ * Update the range map for visualizing date ranges
+ */
+export declare function updateRangeMap(start: Date, end: Date): TDateRangeMap;
+/**
+ * Check if a range selection is allowed (no excluded dates in between)
+ */
+export declare function isRangeAllowed(date: Date, selectedDates: Date[], excludedates: Date[], excludeweekdays: string[]): boolean;
+/**
+ * Add a date to the selection
+ */
+export declare function addToSelection(selectedDate: Date, currentSelected: string[]): string[];
+/**
+ * Remove a date from the selection
+ */
+export declare function removeFromSelection(selectedDate: Date, currentSelected: string[]): string[];
+/**
+ * Toggle a date in the selection
+ */
+export declare function toggleSelection(selectedDate: Date, currentSelected: string[], maxMultiple: number): string[];
+/**
+ * Handle range selection logic
+ */
+export declare function handleRangeSelection(selectedDate: Date, currentSelected: string[], options: Pick<ISelectionOptions, 'excludedates' | 'excludeweekdays'>): string[];

package/dist/shared-utils/combobox/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared combobox utilities for use by both Elements and React packages.
+ */
+export { findOptionByValue, findOptionIndex, filterOptionsBySearch, buildFulltext, isMaxSelectionReached, getOptionDisplayText, parseValueToArray, findTypeaheadMatches, getSearchInfoMessage, } from './option-utils';
+export { selectOption, deselectOption, selectAllOptions, clearAllSelections, createUserOption, toggleSelection, } from './selection-manager';
+export type { IToggleSelectionConfig, IToggleSelectionResult } from './selection-manager';
+export { isLetterOrSpace, createTypeaheadHandler, findTypeaheadOptionMatch } from './typeahead';
+export { getInputKeyAction, isArrowToggleKey, getInputValueAction, checkForMatches, getSingleValueForInput, } from './input-utils';
+export type { TInputKeyAction, TFocusOutAction, IFocusOutResult, ICheckForMatchesResult, } from './input-utils';
+export { focusAndScrollIntoView, getOptionElements, focusNextOption, focusPreviousOption, focusFirstOption, focusLastOption, focusFirstOrSelectedOption, } from './keyboard-navigation';

package/dist/shared-utils/combobox/input-utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared combobox input utility functions used by both Elements and React packages.
+ * Covers keyboard actions, focus-out validation, match checking, and input display.
+ */
+import type { IPktComboboxOption } from '../../shared-types/combobox';
+export type TInputKeyAction = 'addValue' | 'focusListbox' | 'closeOptions' | null;
+/**
+ * Determines the action for a keydown event on the combobox input.
+ */
+export declare const getInputKeyAction: (key: string, shiftKey: boolean, multiple: boolean) => TInputKeyAction;
+/**
+ * Determines if a key is an arrow/toggle key for select-only mode.
+ */
+export declare const isArrowToggleKey: (key: string) => boolean;
+export type TFocusOutAction = 'addUserValue' | 'selectOption' | 'removeValue' | 'none';
+export interface IFocusOutResult {
+    action: TFocusOutAction;
+    value: string | null;
+}
+/**
+ * Determines what to do with the input value when focus leaves the combobox.
+ */
+export declare const getInputValueAction: (inputValue: string, currentValues: string[], options: IPktComboboxOption[], allowUserInput: boolean, multiple: boolean) => IFocusOutResult;
+export interface ICheckForMatchesResult {
+    addValueText: string | null;
+    userInfoMessage: string;
+    shouldRemoveValue: boolean;
+    shouldResetInput: boolean;
+}
+/**
+ * Determines the info message and actions based on search input.
+ * Wraps getSearchInfoMessage, adding the empty-input case.
+ */
+export declare const checkForMatches: (inputValue: string, currentValues: string[], options: IPktComboboxOption[], allowUserInput: boolean, multiple: boolean) => ICheckForMatchesResult;
+/**
+ * Determines what text to display in a single-select input for the given value.
+ */
+export declare const getSingleValueForInput: (value: string, options: IPktComboboxOption[], displayValueAs: string) => string;

package/dist/shared-utils/combobox/keyboard-navigation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared combobox keyboard navigation utility functions
+ * used by both Elements and React packages.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Scrolls an element into view and focuses it.
+ */
+export declare const focusAndScrollIntoView: (element: HTMLElement) => void;
+/**
+ * Gets all selectable option elements from a container.
+ */
+export declare const getOptionElements: (container: HTMLElement) => HTMLElement[];
+/**
+ * Focuses the next sibling option.
+ */
+export declare const focusNextOption: (currentTarget: HTMLElement) => void;
+/**
+ * Focuses the previous sibling option.
+ * Falls back to search input if at first option and search is present.
+ */
+export declare const focusPreviousOption: (currentTarget: HTMLElement, container: HTMLElement, includeSearch: boolean) => void;
+/**
+ * Focuses the first option in the list.
+ */
+export declare const focusFirstOption: (container: HTMLElement) => void;
+/**
+ * Focuses the last option in the list.
+ */
+export declare const focusLastOption: (container: HTMLElement) => void;
+/**
+ * Focuses the first selected option, or falls back to search/new-option/first option.
+ */
+export declare const focusFirstOrSelectedOption: (container: HTMLElement, config: {
+    disabled: boolean;
+    allowUserInput: boolean;
+    customUserInput: string | null;
+    includeSearch: boolean;
+}) => void;

package/dist/shared-utils/combobox/option-utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared combobox option utility functions used by both Elements and React packages.
+ * Only framework-agnostic functions belong here.
+ */
+import type { IPktComboboxOption, TPktComboboxDisplayValue } from '../../shared-types/combobox';
+/**
+ * Finds an option by its value, falling back to label match.
+ * Value matches are prioritized over label matches to avoid ambiguity
+ * when an option's label matches another option's value.
+ */
+export declare const findOptionByValue: (options: IPktComboboxOption[], value: string | null) => IPktComboboxOption | null;
+/**
+ * Finds the index of an option by its value, falling back to label match.
+ */
+export declare const findOptionIndex: (options: IPktComboboxOption[], value: string | null) => number;
+/**
+ * Filters options by a search string, matching against fulltext.
+ */
+export declare const filterOptionsBySearch: (options: IPktComboboxOption[], search: string | null) => IPktComboboxOption[];
+/**
+ * Builds the fulltext search string for an option.
+ */
+export declare const buildFulltext: (option: IPktComboboxOption) => string;
+/**
+ * Checks if the maximum number of selections has been reached.
+ */
+export declare const isMaxSelectionReached: (selectedCount: number, maxlength: number | null) => boolean;
+/**
+ * Returns the display text for an option based on the displayValueAs setting.
+ */
+export declare const getOptionDisplayText: (option: IPktComboboxOption | null, displayValueAs: TPktComboboxDisplayValue) => string;
+/**
+ * Parses a value prop (string or string[]) into a normalized array.
+ */
+export declare const parseValueToArray: (value: string | string[] | null | undefined, multiple: boolean) => string[];
+/**
+ * Finds typeahead matches from options based on search input.
+ * Returns filtered options and the best autocomplete suggestion.
+ */
+export declare const findTypeaheadMatches: (options: IPktComboboxOption[], search: string) => {
+    filtered: IPktComboboxOption[];
+    suggestion: IPktComboboxOption | null;
+};
+/**
+ * Determines the user info message based on search state and matches.
+ */
+export declare const getSearchInfoMessage: (searchValue: string, selectedValues: string[], options: IPktComboboxOption[], allowUserInput: boolean) => {
+    addValueText: string | null;
+    userInfoMessage: string;
+};

package/dist/shared-utils/combobox/selection-manager.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared combobox selection management functions used by both Elements and React packages.
+ * Only framework-agnostic functions belong here.
+ */
+import type { IPktComboboxOption } from '../../shared-types/combobox';
+/**
+ * Configuration for the toggleSelection function.
+ */
+export interface IToggleSelectionConfig {
+    multiple: boolean;
+    allowUserInput: boolean;
+    maxlength: number | null;
+}
+/**
+ * Result of a toggle selection operation.
+ * Describes what happened and what the new state should be.
+ */
+export interface IToggleSelectionResult {
+    values: string[];
+    options: IPktComboboxOption[];
+    shouldOptionsBeOpen: boolean;
+    shouldResetInput: boolean;
+    userInfoMessage: string;
+    searchValue: string;
+    newUserOption: IPktComboboxOption | null;
+}
+/**
+ * Marks an option as selected in the options array.
+ * Returns new arrays (immutable).
+ */
+export declare const selectOption: (value: string | null, currentValues: string[], options: IPktComboboxOption[], maxlength: number | null, multiple: boolean) => {
+    values: string[];
+    options: IPktComboboxOption[];
+};
+/**
+ * Removes an option from the selection.
+ * Returns new arrays (immutable).
+ */
+export declare const deselectOption: (value: string | null, currentValues: string[], options: IPktComboboxOption[]) => {
+    values: string[];
+    options: IPktComboboxOption[];
+};
+/**
+ * Selects all options (for multiple mode).
+ * Returns new arrays (immutable).
+ */
+export declare const selectAllOptions: (options: IPktComboboxOption[], maxlength: number | null) => {
+    values: string[];
+    options: IPktComboboxOption[];
+    userInfoMessage: string;
+};
+/**
+ * Clears all selections.
+ * Returns new arrays (immutable).
+ */
+export declare const clearAllSelections: (options: IPktComboboxOption[]) => {
+    values: string[];
+    options: IPktComboboxOption[];
+};
+/**
+ * Creates a new user-added option object.
+ */
+export declare const createUserOption: (value: string) => IPktComboboxOption;
+/**
+ * Core toggle selection logic.
+ *
+ * Given a value to toggle and the current state, returns the new state
+ * describing what happened. This is the framework-agnostic version of
+ * the combobox's toggleValue method.
+ */
+export declare const toggleSelection: (value: string | null, currentValues: string[], options: IPktComboboxOption[], config: IToggleSelectionConfig) => IToggleSelectionResult;

package/dist/shared-utils/combobox/typeahead.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared combobox typeahead utility functions used by both Elements and React packages.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Checks if a character is a letter or space (Unicode-aware).
+ */
+export declare const isLetterOrSpace: (char: string) => boolean;
+/**
+ * Creates a typeahead handler that manages debounced character accumulation.
+ * Returns a stateful handler — call destroy() when done to clear timeouts.
+ */
+export declare const createTypeaheadHandler: (timeout?: number) => {
+    append: (char: string) => string;
+    reset: () => void;
+    getBuffer: () => string;
+};
+/**
+ * Finds the first option element whose text content starts with the search string.
+ * Works with an array of elements, matching against textContent.
+ */
+export declare const findTypeaheadOptionMatch: (options: {
+    textContent: string | null;
+}[], searchString: string) => number;

package/dist/shared-utils/date-utils.d.ts

@@ -0,0 +1,138 @@
+import { TZDate } from '@date-fns/tz';
+declare global {
+    interface Window {
+        pktTz: string;
+    }
+}
+/**
+ * Returns the current date in the specified timezone, with time set to 00:00:00
+ * @param tz - Timezone string (default: window.pktTz)
+ * @returns Date object representing today's date in the specified timezone
+ */
+export declare const todayInTz: (tz?: string) => Date;
+/**
+ * Parses an ISO date string and returns a Date object.
+ * Handles "YYYY-MM-DD", "YYYY-MM", and "YYYY" formats as local dates.
+ * @param date - The ISO date string to parse
+ * @returns A Date object
+ */
+export declare function parseISODateString(date: string | null | undefined): Date;
+/**
+ * Formats a Date or TZDate object to an ISO date string (YYYY-MM-DD).
+ * Uses local time, not UTC.
+ * @param date - The Date or TZDate object to format
+ * @returns An ISO date string
+ */
+export declare const formatISODate: (date: Date | TZDate) => string;
+/**
+ * Converts an ISO date string to a Date object
+ * @param date - The ISO date string to convert
+ * @returns A Date object or null if invalid
+ */
+export declare const fromISOToDate: (date: string | null) => Date | null;
+/**
+ * Converts an ISO date string to a formatted date string
+ * @param date - The ISO date string to convert
+ * @param dateformat - The desired date format
+ * @returns A formatted date string
+ */
+export declare const fromISOtoLocal: (date: string, dateformat: string) => string;
+/**
+ * Creates a new Date object based on the provided date string or Date object.
+ * Optionally sets the time to the start or end of the day.
+ * @param date - The date string or Date object
+ * @param timeOfDay - 'start' to set time to 00:00:00, 'end' to set time to 23:59:59
+ * @returns A Date object
+ */
+export declare const newDate: (date?: string | Date, timeOfDay?: "start" | "end") => Date;
+/**
+ * Creates a new Date object based on the provided year, month, and day.
+ * If the inputs are invalid, returns the current date.
+ * @param year - The year
+ * @param month - The month (0-11)
+ * @param day - The day of the month (default: 1)
+ * @returns A Date object
+ */
+export declare const newDateYMD: (year: number, month: number, day?: number) => Date;
+/**
+ * Creates a new Date object based on the provided date string or Date object.
+ * Sets the time to noon (12:00:00) to avoid timezone issues.
+ * @param date - The date string or Date object
+ * @returns A Date object with time set to noon
+ */
+export declare const newDateFromDate: (date: Date | TZDate | number) => Date;
+export declare const formatReadableDate: (date: Date | TZDate) => string;
+/**
+ * Validates if a date is within the specified range
+ * @param date - The date to validate
+ * @param min - The minimum date (ISO string)
+ * @param max - The maximum date (ISO string)
+ * @returns boolean indicating if the date is in range
+ */
+export declare const isDateInRange: (date: Date, min?: string | null, max?: string | null) => boolean;
+/**
+ * Checks if a date is in the list of excluded dates
+ * @param date - The date to check
+ * @param excludedDates - Array of excluded date strings (ISO format)
+ * @returns boolean indicating if the date is excluded
+ */
+export declare const isDateExcluded: (date: Date, excludedDates: string[]) => boolean;
+/**
+ * Checks if a date's weekday is excluded
+ * @param date - The date to check
+ * @param excludedWeekdays - Array of excluded weekdays (0 = Sunday, 1 = Monday, etc.)
+ * @returns boolean indicating if the weekday is excluded
+ */
+export declare const isWeekdayExcluded: (date: Date, excludedWeekdays: string[]) => boolean;
+/**
+ * Validates if a date can be selected based on all constraints
+ * @param date - The date to validate
+ * @param min - The minimum date (ISO string)
+ * @param max - The maximum date (ISO string)
+ * @param excludedDates - Array of excluded date strings (ISO format)
+ * @param excludedWeekdays - Array of excluded weekdays (0 = Sunday, 1 = Monday, etc.)
+ * @returns boolean indicating if the date is selectable
+ */
+export declare const isDateSelectable: (date: Date, min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => boolean;
+/**
+ * Filters an array of date strings to only include selectable dates
+ * @param dates - Array of date strings (ISO format)
+ * @param min - The minimum date (ISO string)
+ * @param max - The maximum date (ISO string)
+ * @param excludedDates - Array of excluded date strings (ISO format)
+ * @param excludedWeekdays - Array of excluded weekdays (0 = Sunday, 1 = Monday, etc.)
+ * @returns Array of selectable date strings
+ */
+export declare const filterSelectableDates: (dates: string[], min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => string[];
+/**
+ * Sorts an array of ISO date strings chronologically
+ * @param dates - Array of date strings (ISO format)
+ * @returns Sorted array of date strings
+ */
+export declare const sortDateStrings: (dates: string[]) => string[];
+/**
+ * Validates a date range (start should be before or equal to end)
+ * @param startDate - The start date (ISO string)
+ * @param endDate - The end date (ISO string)
+ * @returns boolean indicating if the date range is valid
+ */
+export declare const isValidDateRange: (startDate: string, endDate: string) => boolean;
+declare const _default: {
+    todayInTz: (tz?: string) => Date;
+    parseISODateString: typeof parseISODateString;
+    formatISODate: (date: Date | TZDate) => string;
+    fromISOToDate: (date: string | null) => Date | null;
+    fromISOtoLocal: (date: string, dateformat: string) => string;
+    newDate: (date?: string | Date, timeOfDay?: "start" | "end") => Date;
+    newDateYMD: (year: number, month: number, day?: number) => Date;
+    newDateFromDate: (date: Date | TZDate | number) => Date;
+    formatReadableDate: (date: Date | TZDate) => string;
+    isDateInRange: (date: Date, min?: string | null, max?: string | null) => boolean;
+    isDateExcluded: (date: Date, excludedDates: string[]) => boolean;
+    isWeekdayExcluded: (date: Date, excludedWeekdays: string[]) => boolean;
+    isDateSelectable: (date: Date, min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => boolean;
+    filterSelectableDates: (dates: string[], min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => string[];
+    sortDateStrings: (dates: string[]) => string[];
+    isValidDateRange: (startDate: string, endDate: string) => boolean;
+};
+export default _default;

package/dist/shared-utils/datepicker-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Shared datepicker utility functions used by both Elements and React packages.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Determines the appropriate input type based on device.
+ * Returns 'text' on iOS to avoid native date picker conflicts.
+ */
+export declare const getDatepickerInputType: () => string;
+/**
+ * Validates that a range has valid order (start <= end).
+ * Returns true if range is valid or incomplete.
+ */
+export declare const validateRangeOrder: (values: string[]) => boolean;
+/**
+ * Sorts date strings chronologically.
+ */
+export declare const sortDates: (dates: string[]) => string[];
+/**
+ * Filters dates to only include selectable ones based on constraints.
+ */
+export declare const filterDates: (dates: string[], min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => string[];
+/**
+ * Generates input CSS classes for datepicker.
+ */
+export declare const getDatepickerInputClasses: (fullwidth: boolean, showRangeLabels: boolean, multiple: boolean, range: boolean, readonly?: boolean, inputType?: string) => Record<string, boolean>;
+/**
+ * Generates button CSS classes for calendar toggle button.
+ */
+export declare const getDatepickerButtonClasses: () => Record<string, boolean>;
+/**
+ * Generates range label CSS classes.
+ */
+export declare const getRangeLabelClasses: (showRangeLabels: boolean) => Record<string, boolean>;
+/**
+ * Processes date selection from calendar events.
+ * Converts the calendar's date selection into the appropriate string format.
+ */
+export declare const processDateSelection: (detail: string | string[], multiple: boolean, range: boolean) => string;
+/**
+ * Handles calendar positioning based on viewport and input position.
+ * Positions calendar below input by default, flips above if overflowing.
+ *
+ * Accepts plain DOM elements (not framework-specific refs).
+ */
+export declare const handleCalendarPosition: (popup: HTMLElement | null, input: HTMLElement | null, hasCounter?: boolean) => void;
+/**
+ * Handles common keyboard interactions for datepicker inputs.
+ *
+ * - Space: Opens calendar
+ * - Enter: Submits form, focuses next input, or blurs
+ * - Comma: Adds date to selection (multiple) or blurs input
+ */
+export declare const handleDatepickerKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void, submitForm?: () => void, focusNextInput?: () => void, blurInput?: () => void, commaHandler?: (e: KeyboardEvent) => void) => void;
+/**
+ * Handles keyboard interactions for calendar button.
+ * Responds to Enter and Space keys.
+ */
+export declare const handleDatepickerButtonKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void) => void;
+declare const _default: {
+    getDatepickerInputType: () => string;
+    validateRangeOrder: (values: string[]) => boolean;
+    sortDates: (dates: string[]) => string[];
+    filterDates: (dates: string[], min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => string[];
+    getDatepickerInputClasses: (fullwidth: boolean, showRangeLabels: boolean, multiple: boolean, range: boolean, readonly?: boolean, inputType?: string) => Record<string, boolean>;
+    getDatepickerButtonClasses: () => Record<string, boolean>;
+    getRangeLabelClasses: (showRangeLabels: boolean) => Record<string, boolean>;
+    processDateSelection: (detail: string | string[], multiple: boolean, range: boolean) => string;
+    handleCalendarPosition: (popup: HTMLElement | null, input: HTMLElement | null, hasCounter?: boolean) => void;
+    handleDatepickerKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void, submitForm?: () => void, focusNextInput?: () => void, blurInput?: () => void, commaHandler?: (e: KeyboardEvent) => void) => void;
+    handleDatepickerButtonKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void) => void;
+};
+export default _default;

package/dist/shared-utils/device-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Detects if the current device is iOS (iPhone, iPad, iPod)
+ * Handles modern iPad Safari which uses desktop user agent since iOS 13
+ * @returns boolean indicating if the device is iOS
+ */
+export declare const isIOS: () => boolean;
+declare const _default: {
+    isIOS: () => boolean;
+};
+export default _default;

package/dist/shared-utils/timepicker/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared timepicker utilities for use by both Elements and React packages.
+ */
+export { isValidTimeString, parseTimeString, timeToMinutes } from './time-utils';
+export { getMinuteStep, getHourOptions, getMinuteOptions } from './options';
+export { stepTime } from './stepper';

package/dist/shared-utils/timepicker/options.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared timepicker option generation utilities.
+ * Used by both Elements and React implementations.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Converts a step value in seconds to a step value in minutes.
+ * Defaults to 1 if step is null/undefined/zero.
+ */
+export declare const getMinuteStep: (stepSeconds?: number | null) => number;
+/**
+ * Returns an array of valid hour values (0–23) based on min/max constraints.
+ * min and max should be HH:MM strings; invalid/missing values fall back to 0 and 23.
+ */
+export declare const getHourOptions: (min?: string | number | null, max?: string | number | null) => number[];
+/**
+ * Returns an array of valid minute values based on step constraints.
+ */
+export declare const getMinuteOptions: (stepSeconds?: number | null) => number[];

package/dist/shared-utils/timepicker/stepper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared timepicker stepper logic.
+ * Used by both Elements and React implementations.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Increments or decrements the time by one minute-step.
+ * Rolls over: incrementing past 23:59 wraps to 00:00, and decrementing past 00:00 wraps to 23:59.
+ * Falls back to sensible defaults when hours/minutes are empty strings.
+ *
+ * @param hours - Current hours display value ('09', '', etc.)
+ * @param minutes - Current minutes display value ('30', '', etc.)
+ * @param direction - 1 for next, -1 for previous
+ * @param minuteStep - Step size in minutes
+ * @returns Zero-padded { hours, minutes } strings
+ */
+export declare const stepTime: (hours: string, minutes: string, direction: 1 | -1, minuteStep: number) => {
+    hours: string;
+    minutes: string;
+};

package/dist/shared-utils/timepicker/time-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared timepicker time utility functions.
+ * Used by both Elements and React implementations.
+ * Only framework-agnostic functions belong here.
+ */
+/**
+ * Returns true if the string matches the HH:MM format with valid hour/minute ranges.
+ */
+export declare const isValidTimeString: (value: string) => boolean;
+/**
+ * Parses an HH:MM string into zero-padded [hours, minutes] strings.
+ * Returns null for empty or invalid values.
+ */
+export declare const parseTimeString: (value: string) => [string, string] | null;
+/**
+ * Converts an HH:MM string to total minutes since midnight.
+ * Assumes a valid time string.
+ */
+export declare const timeToMinutes: (time: string) => number;

package/dist/shared-utils/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Sleep utility function for async delays
+ * @param ms - Number of milliseconds to sleep
+ * @returns A promise that resolves after the specified delay
+ */
+export declare const sleep: (ms: number) => Promise<void>;
+/**
+ * UUID-like string generator for very random identifiers
+ * @returns A UUID-like string (Not actually a valid UUID)
+ */
+export declare const uuidish: () => string;
+declare const _default: {
+    sleep: (ms: number) => Promise<void>;
+    uuidish: () => string;
+};
+export default _default;

package/dist/shared-utils/value-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a value (string or string array) into an array of strings
+ * @param value - The value to convert
+ * @returns An array of strings
+ */
+export declare const valueToArray: (value: string | string[] | null | undefined) => string[];
+/**
+ * Converts an array of strings into a CSV string
+ * @param array - The array of strings to convert
+ * @returns A CSV string
+ */
+export declare const arrayToCsv: (array: string[]) => string;
+declare const _default: {
+    valueToArray: (value: string | string[] | null | undefined) => string[];
+    arrayToCsv: (array: string[]) => string;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oslokommune/punkt-react",
-  "version": "16.9.0",
+  "version": "16.9.1",
   "description": "React komponentbibliotek til Punkt, et designsystem laget av Oslo Origo",
   "homepage": "https://punkt.oslo.kommune.no",
   "author": "Team Designsystem, Oslo Origo",
@@ -27,7 +27,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "tsc && vite build",
+    "build": "tsc && vite build && node scripts/bundle-shared-types.js",
     "build-app": "tsc && vite build --config vite.config-app.ts",
     "lint": "eslint 'src/**/*.{js,jsx,ts,tsx}'",
     "lint:fix": "eslint --fix 'src/**/*.{jsx,ts,tsx}'",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@lit-labs/ssr-dom-shim": "^1.2.1",
     "@lit/react": "^1.0.7",
-    "@oslokommune/punkt-elements": "^16.9.0",
+    "@oslokommune/punkt-elements": "^16.9.1",
     "classnames": "^2.5.1",
     "prettier": "^3.3.3",
     "react-hook-form": "^7.53.0"
@@ -50,7 +50,7 @@
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.37.0",
     "@oslokommune/punkt-assets": "^16.0.0",
-    "@oslokommune/punkt-css": "^16.8.2",
+    "@oslokommune/punkt-css": "^16.9.1",
     "@testing-library/jest-dom": "^6.5.0",
     "@testing-library/react": "^16.0.1",
     "@testing-library/user-event": "^14.5.2",
@@ -109,5 +109,5 @@
     "url": "https://github.com/oslokommune/punkt/issues"
   },
   "license": "MIT",
-  "gitHead": "b5986d27e787fefda72f847d65bb9b7de2ab5316"
+  "gitHead": "88ccfdd5b0afd0db0c4f18e93b772b578f3fd9d7"
 }