@povio/ui 3.4.0-rc.3 → 3.4.0-rc.30

package/dist/useTableNav-CFHbvYvu.d.ts

@@ -0,0 +1,274 @@
+import { n as StyleMergeUtils, t as UIOverrides } from "./uiOverrides.context-BdokYcGO.js";
+import { c as ZodObject, h as output, i as ZodEnum } from "./schemas-CAtYiHoz.js";
+import { t as FieldPath } from "./form.binding-DWlFTecs.js";
+import { ComponentType, Dispatch, KeyboardEvent, ReactNode, SetStateAction } from "react";
+import { CellContext, ColumnDef, ColumnMeta, ColumnOrderState, ColumnVisibilityState, OnChangeFn, PaginationState, Row, RowData, RowSelectionState, SortingState, StockFeatures, Table } from "@tanstack/react-table";
+import { TFunction } from "i18next";
+import { DragEndEvent, UniqueIdentifier } from "@dnd-kit/core";
+//#region src/components/table/ColumnConfig.d.ts
+type ColumnDef$4<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type VisibilityState$2 = ColumnVisibilityState;
+interface ColumnConfigModalProps<TData extends RowData, TValue> {
+  isOpen: boolean;
+  onClose: () => void;
+  configColumns: ColumnDef$4<TData, TValue>[];
+  visibleColumns: VisibilityState$2;
+  onVisibilityChange: (visibleColumns: VisibilityState$2) => void;
+  onOrderChange: (columnOrder: ColumnOrderState) => void;
+}
+declare function ColumnConfigModal<TData extends RowData, TValue>({ isOpen, onClose, configColumns, visibleColumns, onVisibilityChange, onOrderChange }: ColumnConfigModalProps<TData, TValue>): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+//#region src/components/table/table.cva.d.ts
+declare const tableRowDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly alternatingBackground: {
+      readonly even: "even:bg-elevation-fill-inverted-4/5";
+      readonly odd: "odd:bg-elevation-fill-inverted-4/5";
+    };
+  }>;
+};
+type TableRowConfig = NonNullable<typeof tableRowDefinition.config>;
+interface TableRowVariantProps extends UIOverrides.VariantProps<TableRowConfig> {}
+declare const tableHeadRowDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+declare const tableHeadDataDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly hasRightBorder: {
+      readonly true: "border-l border-l-elevation-outline-default-1 border-solid";
+      readonly false: "";
+    };
+  }>;
+};
+declare const tableDataDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly hasRightBorder: {
+      readonly true: "border-l border-l-elevation-outline-default-1";
+      readonly false: "";
+    };
+  }>;
+};
+declare const tableHeaderTextDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+declare const tableCellTextDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+//#endregion
+//#region src/components/table/Table.d.ts
+type ColumnDef$3<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type ReactTable<TData extends RowData> = Table<StockFeatures, TData>;
+type Row$1<TData extends RowData> = Row<StockFeatures, TData>;
+type VisibilityState$1 = ColumnVisibilityState;
+type BulkSelectionActionsComponent<T extends RowData> = ComponentType<{
+  table: ReactTable<T>;
+}>;
+interface TableWrapperProps<T extends RowData> extends Omit<TableProps<T>, "columns"> {}
+interface TableProps<T extends RowData> extends TableRowVariantProps {
+  items: T[];
+  columns: ((t: TFunction) => ColumnDef$3<T>[]) | ColumnDef$3<T>[];
+  showCellBorder?: boolean;
+  onRowClick?: (row: T) => void;
+  onDoubleClick?: (row: T) => void;
+  className?: string;
+  sorting?: SortingState;
+  setSorting?: Dispatch<SetStateAction<SortingState>>;
+  columnOrder?: ColumnOrderState;
+  setColumnOrder?: Dispatch<SetStateAction<ColumnOrderState>>;
+  columnVisibility?: VisibilityState$1;
+  setColumnVisibility?: Dispatch<SetStateAction<VisibilityState$1>>;
+  bulkSelectionActions?: BulkSelectionActionsComponent<T>;
+  enableDragDrop?: boolean;
+  onDragEnd?: (event: DragEndEvent) => void;
+  onReorder?: (reorderedItems: T[]) => void;
+  getRowId?: (row: T) => UniqueIdentifier;
+  enableRowSelection?: boolean | ((row: Row$1<T>) => boolean);
+  enableMultiRowSelection?: boolean | ((row: Row$1<T>) => boolean);
+  defaultSelectedRows?: RowSelectionState;
+  onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+}
+declare const Table$1: <T extends RowData>({ items, showCellBorder, columns, onRowClick, onDoubleClick, className, sorting, setSorting, columnOrder, setColumnOrder, columnVisibility, setColumnVisibility, bulkSelectionActions: ActionHeader, enableDragDrop, onDragEnd, onReorder, getRowId, enableRowSelection, enableMultiRowSelection, defaultSelectedRows, onRowSelectionChange, ...props }: TableProps<T>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/table/InfiniteTable.d.ts
+interface InfiniteTableWrapperProps<T extends RowData> extends Omit<InfiniteTableProps<T>, "columns"> {}
+interface InfiniteTableProps<T extends RowData> extends TableProps<T> {
+  hasNextPage: boolean;
+  isFetchingNextPage?: boolean;
+  fetchNextPage: () => void;
+}
+declare const InfiniteTable: <T extends RowData>({ hasNextPage, isFetchingNextPage, fetchNextPage, ...rest }: InfiniteTableProps<T>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/table/PaginatedTable.d.ts
+interface PaginatedTableWrapperProps<T extends RowData> extends Omit<PaginatedTableProps<T>, "columns"> {}
+interface PaginatedTableProps<T extends RowData> extends TableProps<T> {
+  totalItems: number;
+  pagination: PaginationState;
+  setPagination: Dispatch<SetStateAction<PaginationState>>;
+}
+declare const PaginatedTable: <T extends RowData>({ pagination, setPagination, items, totalItems, ...rest }: PaginatedTableProps<T>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/helpers/dynamicColumns.d.ts
+type CellContext$1<TData extends RowData, TValue> = CellContext<StockFeatures, TData, TValue>;
+type ColumnDef$2<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type ColumnMeta$1<TData extends RowData, TValue> = ColumnMeta<StockFeatures, TData, TValue>;
+type NestedTypeFromKey<T, K extends string> = K extends keyof T ? T[K] : K extends `${infer First}.${infer Rest}` ? First extends keyof T ? NestedTypeFromKey<T[First], Rest> : never : never;
+type SchemaType<TSchema extends ZodObject<any>> = output<TSchema>;
+type SchemaKey<TSchema extends ZodObject<any>> = keyof SchemaType<TSchema>;
+type NestedSchemaKey<TSchema extends ZodObject<any>> = FieldPath<SchemaType<TSchema>>;
+type SchemaValue<TSchema extends ZodObject<any>> = SchemaType<TSchema>[SchemaKey<TSchema>];
+type ColumnMetaType<TSchema extends ZodObject<any>> = ColumnMeta$1<SchemaType<TSchema>, SchemaValue<TSchema>>;
+type GetNestedValueType<TSchema extends ZodObject<any>, K extends string> = NestedTypeFromKey<SchemaType<TSchema>, K>;
+type NestedSchemaKeyOrString<TSchema extends ZodObject<any>> = NestedSchemaKey<TSchema> | (string & {});
+type DynamicColumnDef<TSchema extends ZodObject<any>, TValue = any> = Omit<ColumnDef$2<SchemaType<TSchema>, TValue>, "accessorKey" | "cell"> & {
+  cell?: ((props: CellContext$1<SchemaType<TSchema>, TValue>) => any) | NestedSchemaKey<TSchema>;
+};
+type ColumnsConfig<TSchema extends ZodObject<any>> = { [K in NestedSchemaKey<TSchema>]?: DynamicColumnDef<TSchema, GetNestedValueType<TSchema, K>> | ((props: CellContext$1<SchemaType<TSchema>, GetNestedValueType<TSchema, K>>) => any) | NestedSchemaKey<TSchema> | boolean; };
+type CustomColumnDef<TSchema extends ZodObject<any>> = Omit<ColumnDef$2<SchemaType<TSchema>, any>, "accessorKey" | "cell"> & {
+  accessorKey?: NestedSchemaKeyOrString<TSchema>;
+  cell?: ((props: CellContext$1<SchemaType<TSchema>, any>) => any) | NestedSchemaKey<TSchema>;
+};
+type CustomColumnsConfig<TSchema extends ZodObject<any>> = Record<string, CustomColumnDef<TSchema> | ((props: CellContext$1<SchemaType<TSchema>, undefined>) => any) | NestedSchemaKey<TSchema>>;
+interface DynamicColumnsOptions<TSchema extends ZodObject<any>> {
+  columns?: ColumnsConfig<TSchema>;
+  customColumns?: CustomColumnsConfig<TSchema>;
+  order?: NestedSchemaKeyOrString<TSchema>[];
+  sortable?: NestedSchemaKeyOrString<TSchema>[] | ZodEnum<any>;
+  disableFormatting?: NestedSchemaKeyOrString<TSchema>[];
+  emptyValue?: ReactNode;
+  namespace?: string;
+  overridePresetLocales?: boolean;
+  globalMeta?: Omit<ColumnMetaType<TSchema>, "sortKey">;
+  globalWrapper?: (children: ReactNode) => ReactNode;
+  includeAll?: boolean;
+}
+interface DynamicColumnsParams<TSchema extends ZodObject<any>> {
+  schema: TSchema;
+  preset?: ColumnDef$2<SchemaType<TSchema>>[];
+  options: DynamicColumnsOptions<TSchema>;
+}
+declare const dynamicColumns: <TSchema extends ZodObject<any>>({ schema, preset, options }: DynamicColumnsParams<TSchema>) => ColumnDef$2<SchemaType<TSchema>>[];
+//#endregion
+//#region src/hooks/usePagination.d.ts
+declare function usePagination(defaultPagination?: PaginationState): {
+  pagination: PaginationState;
+  setPagination: import("react").Dispatch<import("react").SetStateAction<PaginationState>>;
+  pageIndex: number;
+  pageSize: number;
+};
+//#endregion
+//#region src/hooks/useSorting.d.ts
+declare function useSorting(defaultSorting?: SortingState, prefix?: string): {
+  sorting: SortingState;
+  setSorting: import("react").Dispatch<import("react").SetStateAction<SortingState>>;
+  order: string;
+};
+//#endregion
+//#region src/hooks/useTableColumnConfig.d.ts
+type ColumnDef$1<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type VisibilityState = ColumnVisibilityState;
+interface UseTableColumnConfigOptions {
+  visibleColumns?: VisibilityState;
+  columnOrder?: ColumnOrderState;
+  onVisibilityChange?: (value: VisibilityState) => void;
+  onOrderChange?: (value: ColumnOrderState) => void;
+}
+declare function useTableColumnConfig<TData extends RowData, TValue>(defaultColumns: ColumnDef$1<TData, TValue>[], options?: UseTableColumnConfigOptions): {
+  configColumns: ColumnDef$1<TData, TValue>[];
+  columns: ColumnDef$1<TData, TValue>[];
+  visibleColumns: ColumnVisibilityState;
+  columnOrder: ColumnOrderState;
+  onVisibilityChange: (value: VisibilityState) => void;
+  onOrderChange: (value: ColumnOrderState) => void;
+};
+//#endregion
+//#region src/hooks/useTableNav.d.ts
+declare const Selectors: {
+  readonly Cell: '[role="cell"],[role="gridcell"],[role="columnheader"],[role="rowheader"],td,th';
+  readonly Row: '[role="row"],tr';
+  readonly RowGroup: '[role="rowgroup"],thead,tbody,tfoot';
+  /** Selector from here: https://github.com/Shopify/polaris/blob/main/polaris-react/src/utilities/focus.ts#L10 */
+  readonly Focusable: 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not([aria-disabled="true"]):not([tabindex="-1"]):not(:disabled),*[tabindex]';
+};
+type Config = {
+  /** Enable debug logs */
+  debug?: boolean;
+  /** CSS Selectors being used to find Rows, Row Groups, Cells and Focusable elements */
+  selectors?: Partial<typeof Selectors>;
+  /** How many rows to move when pressing page up/down - Default goes to first/last row */
+  pageUpDown?: number;
+} | undefined;
+declare class DataGridNav {
+  private selectors;
+  readonly pageUpDown: number | undefined;
+  private keys;
+  private disabled;
+  readonly debug: boolean;
+  private activeCell;
+  constructor();
+  constructor(config: Config);
+  private debugLog;
+  /**
+   * Disables the keyboard listener in cases
+   * that elements inside the grid need to use
+   * arrows keys etc., like select dropdowns
+   */
+  disable(): void;
+  /**
+   * Enables the keyboard listeners
+   */
+  enable(): void;
+  private isFocusable;
+  getActiveCell(): HTMLElement | null;
+  /** Used as a keyboard listener for key up */
+  tableKeyUp(): void;
+  /** Used as a keyboard listener for key down */
+  tableKeyDown(e: KeyboardEvent): void;
+  /**
+   * Handles the navigation inside a cell
+   */
+  cellNavigation(e: KeyboardEvent): void;
+  /**
+   * Handles the navigation outside a cell
+   * on the grid level
+   */
+  gridNavigation(e: KeyboardEvent): void;
+  private pageCellNavigation;
+  private verticalCellNavigation;
+  /**
+   * Sending a row `Element` and then the first cell will be focused.
+   *
+   * If you want to focus the last cell then the row children can be passed in
+   * reversed order
+   */
+  private focusOnFirstCell;
+  /**
+   * Get the column index of a `cell` based on the first `row` parent.
+   * `cellIndex` could be used, but it's not supported in HTML tables.
+   */
+  private getColumnIndex;
+  /**
+   * Get the row index of a `row` based
+   * on its sibling rows
+   */
+  private getRowIndex;
+  /**
+   * Equivalent to prevUntil/nextUntil in jQuery
+   * https://api.jquery.com/prevUntil/
+   */
+  private findUntil;
+}
+declare function useTableNav(options?: Config): {
+  listeners: {
+    onKeyDown: (e: KeyboardEvent) => void;
+    onKeyUp: () => void;
+  };
+  tableNav: DataGridNav;
+};
+//#endregion
+export { ColumnConfigModal as C, tableRowDefinition as S, tableCellTextDefinition as _, DynamicColumnsOptions as a, tableHeadRowDefinition as b, PaginatedTableProps as c, InfiniteTableProps as d, InfiniteTableWrapperProps as f, TableRowVariantProps as g, TableWrapperProps as h, usePagination as i, PaginatedTableWrapperProps as l, TableProps as m, useTableColumnConfig as n, dynamicColumns as o, Table$1 as p, useSorting as r, PaginatedTable as s, useTableNav as t, InfiniteTable as u, tableDataDefinition as v, ColumnConfigModalProps as w, tableHeaderTextDefinition as x, tableHeadDataDefinition as y };

package/dist/useToast-B55ZUvwy.d.ts

@@ -0,0 +1,16 @@
+import { n as ToastOptions$1, r as ToastPosition, t as Id } from "./index-B8r_kiw4.js";
+import { r as ToastProps } from "./Toast-JL9yaI35.js";
+//#region src/components/status/Toast/useToast.d.ts
+interface ToastParams extends Omit<ToastProps, "color"> {
+  position?: ToastPosition;
+}
+type ToastOptions = Omit<ToastOptions$1, "position" | "data">;
+declare const useToast: () => {
+  successToast: (params: ToastParams, options?: ToastOptions) => Id;
+  errorToast: (params: ToastParams, options?: ToastOptions) => Id;
+  warningToast: (params: ToastParams, options?: ToastOptions) => Id;
+  neutralToast: (params: ToastParams, options?: ToastOptions) => Id;
+  closeToast: (id: Id) => void;
+};
+//#endregion
+export { ToastParams as n, useToast as r, ToastOptions as t };

package/dist/useToggle-D8aP2d5t.js

@@ -0,0 +1,63 @@
+import { d as $3ef42575df84b30b$export$9d1611c77c2fe928 } from "./utils-D-KKbY-n.js";
+import { a as $65484d02dcb7eb3e$export$457c3d6518dd4c6f } from "./import-BXAtbYEe.js";
+import { t as $99facab73266f662$export$5add1d006293d136 } from "./useFormReset-BmSQIMid.js";
+import { useFocusable, usePress } from "@react-aria/interactions";
+//#region ../../node_modules/.bun/@react-aria+toggle@3.12.4+67f6792bdf102c28/node_modules/@react-aria/toggle/dist/useToggle.mjs
+function $d2c8e2b0480f3f34$export$cbe85ee05b554577(props, state, ref) {
+	let { isDisabled = false, isReadOnly = false, value, name, form, children, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, validationState = "valid", isInvalid, onPressStart, onPressEnd, onPressChange, onPress, onPressUp, onClick } = props;
+	let onChange = (e) => {
+		e.stopPropagation();
+		state.setSelected(e.target.checked);
+	};
+	if (!(children != null) && !(ariaLabel != null || ariaLabelledby != null) && true) console.warn("If you do not provide children, you must specify an aria-label for accessibility");
+	let { pressProps, isPressed } = usePress({
+		onPressStart,
+		onPressEnd,
+		onPressChange,
+		onPress,
+		onPressUp,
+		onClick,
+		isDisabled
+	});
+	let { pressProps: labelProps, isPressed: isLabelPressed } = usePress({
+		onPressStart,
+		onPressEnd,
+		onPressChange,
+		onPressUp,
+		onClick,
+		onPress(e) {
+			var _ref_current;
+			onPress === null || onPress === void 0 || onPress(e);
+			state.toggle();
+			(_ref_current = ref.current) === null || _ref_current === void 0 || _ref_current.focus();
+		},
+		isDisabled: isDisabled || isReadOnly
+	});
+	let { focusableProps } = useFocusable(props, ref);
+	let interactions = $3ef42575df84b30b$export$9d1611c77c2fe928(pressProps, focusableProps);
+	let domProps = $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, { labelable: true });
+	$99facab73266f662$export$5add1d006293d136(ref, state.defaultSelected, state.setSelected);
+	return {
+		labelProps: $3ef42575df84b30b$export$9d1611c77c2fe928(labelProps, { onClick: (e) => e.preventDefault() }),
+		inputProps: $3ef42575df84b30b$export$9d1611c77c2fe928(domProps, {
+			"aria-invalid": isInvalid || validationState === "invalid" || void 0,
+			"aria-errormessage": props["aria-errormessage"],
+			"aria-controls": props["aria-controls"],
+			"aria-readonly": isReadOnly || void 0,
+			onChange,
+			disabled: isDisabled,
+			...value == null ? {} : { value },
+			name,
+			form,
+			type: "checkbox",
+			...interactions
+		}),
+		isSelected: state.isSelected,
+		isPressed: isPressed || isLabelPressed,
+		isDisabled,
+		isReadOnly,
+		isInvalid: isInvalid || validationState === "invalid"
+	};
+}
+//#endregion
+export { $d2c8e2b0480f3f34$export$cbe85ee05b554577 as t };

package/dist/useToggleState-Dyx-sAjp.js

@@ -0,0 +1,23 @@
+import { t as $458b0a5536c1a7cf$export$40bfa8c7b0832715 } from "./useControlledState-Bk39gTui.js";
+import { useState } from "react";
+//#region ../../node_modules/.bun/@react-stately+toggle@3.9.4+83d5fd7b249dbeef/node_modules/@react-stately/toggle/dist/useToggleState.mjs
+function $3017fa7ffdddec74$export$8042c6c013fd5226(props = {}) {
+	let { isReadOnly } = props;
+	let [isSelected, setSelected] = $458b0a5536c1a7cf$export$40bfa8c7b0832715(props.isSelected, props.defaultSelected || false, props.onChange);
+	let [initialValue] = useState(isSelected);
+	function updateSelected(value) {
+		if (!isReadOnly) setSelected(value);
+	}
+	function toggleState() {
+		if (!isReadOnly) setSelected(!isSelected);
+	}
+	var _props_defaultSelected;
+	return {
+		isSelected,
+		defaultSelected: (_props_defaultSelected = props.defaultSelected) !== null && _props_defaultSelected !== void 0 ? _props_defaultSelected : initialValue,
+		setSelected: updateSelected,
+		toggle: toggleState
+	};
+}
+//#endregion
+export { $3017fa7ffdddec74$export$8042c6c013fd5226 as t };

package/dist/useTranslationMemo-CrZbeyBv.js

@@ -0,0 +1,32 @@
+import { c } from "react/compiler-runtime";
+import { useTranslation } from "react-i18next";
+//#region src/hooks/useTranslationMemo.ts
+function useTranslationMemo(func) {
+	const $ = c(5);
+	const { t } = useTranslation();
+	let t0;
+	bb0: {
+		if (func.length === 1) {
+			let t1;
+			if ($[0] !== func || $[1] !== t) {
+				t1 = func(t);
+				$[0] = func;
+				$[1] = t;
+				$[2] = t1;
+			} else t1 = $[2];
+			t0 = t1;
+			break bb0;
+		}
+		const t1 = func;
+		let t2;
+		if ($[3] !== t1) {
+			t2 = t1();
+			$[3] = t1;
+			$[4] = t2;
+		} else t2 = $[4];
+		t0 = t2;
+	}
+	return t0;
+}
+//#endregion
+export { useTranslationMemo as t };

package/dist/useTranslationMemo-Dy3p6m1g.d.ts

@@ -0,0 +1,6 @@
+import { TFunction } from "i18next";
+//#region src/hooks/useTranslationMemo.d.ts
+type TranslatedFunction<T> = ((t: TFunction) => T) | (() => T);
+declare function useTranslationMemo<T>(func: TranslatedFunction<T>): T;
+//#endregion
+export { useTranslationMemo as t };

package/dist/utils/compound-mapper.d.ts

@@ -0,0 +1,2 @@
+import { r as compoundMapper, t as CompoundMapper } from "../compoundMapper-CMoX98D2.js";
+export { type CompoundMapper, compoundMapper };

package/dist/utils/compound-mapper.js

@@ -0,0 +1,2 @@
+import { t as compoundMapper } from "../compoundMapper-Di3SKZnS.js";
+export { compoundMapper };

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

@@ -0,0 +1,2 @@
+import { t as DateTimeUtils } from "../date-time.utils-Cu9TVj46.js";
+export { DateTimeUtils };

package/dist/utils/date-time.js

@@ -0,0 +1,2 @@
+import { t as DateTimeUtils } from "../date-time.utils-0F9qduim.js";
+export { DateTimeUtils };

package/dist/utils/date.d.ts

@@ -0,0 +1,2 @@
+import { t as DateUtils } from "../date.utils-BoQnMRlF.js";
+export { DateUtils };

package/dist/utils/date.js

@@ -0,0 +1,2 @@
+import { t as DateUtils } from "../date.utils-B8_QF9y6.js";
+export { DateUtils };

package/dist/utils/file.d.ts

@@ -0,0 +1,2 @@
+import { t as FileUtils } from "../file.utils-Crb-mIHs.js";
+export { FileUtils };

package/dist/utils/file.js

@@ -0,0 +1,2 @@
+import { t as FileUtils } from "../file.utils-DqQxnuAm.js";
+export { FileUtils };

package/dist/utils/intl.d.ts

@@ -0,0 +1,2 @@
+import { t as IntlUtils } from "../intl.utils-NaOZUD2G.js";
+export { IntlUtils };

package/dist/utils/intl.js

@@ -0,0 +1,2 @@
+import { t as IntlUtils } from "../intl.utils-zwAFoZ0U.js";
+export { IntlUtils };

package/dist/utils/logger.d.ts

@@ -1,7 +1,2 @@
-export declare const logger: {
-    info: (...args: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    trace: (...args: unknown[]) => void;
-};
+import { t as logger } from "../logger-N35Xhi14.js";
+export { logger };

package/dist/utils/logger.js

@@ -1,19 +1,2 @@
-import log from "loglevel";
-import prefix from "loglevel-plugin-prefix";
-//#region src/utils/logger.ts
-prefix.reg(log);
-prefix.apply(log, {
-	template: "[%t] %l:",
-	timestampFormatter: (date) => {
-		return date.toISOString();
-	}
-});
-var logger = {
-	info: (...args) => log.info(...args),
-	debug: (...args) => log.debug(...args),
-	warn: (...args) => log.warn(...args),
-	error: (...args) => log.error(...args),
-	trace: (...args) => log.trace(...args)
-};
-//#endregion
+import { t as logger } from "../logger-WPC6ostp.js";
 export { logger };

package/dist/utils/string.d.ts

@@ -0,0 +1,2 @@
+import { t as StringUtils } from "../string.utils-Cj6AB7uZ.js";
+export { StringUtils };

package/dist/utils/string.js

@@ -0,0 +1,2 @@
+import { t as StringUtils } from "../string.utils-BPgv6QwA.js";
+export { StringUtils };