bitboss-ui 2.1.134 → 3.0.0-alpha.1

package/dist/types/CommonProps.d.ts

@@ -1,287 +1,74 @@
-import { HTMLAttributes, InputHTMLAttributes } from 'vue';
-import { VoidHTMLElements } from './VoidHtmlElements';
-import { Classes } from './Classes';
-type NestedKeyOf<ObjectType extends object> = {
-    [Key in keyof ObjectType & (string | number)]: ObjectType[Key] extends object ? `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key]>}` : `${Key}`;
-}[keyof ObjectType & (string | number)];
-export type CommonProps = {
-    /**
-     * Allows typing into the input.
-     */
-    allowWriting?: boolean;
-    /**
-     * Space the arrow will maintain to the edge of the dropdown.
-     * Useful when the floating element has border radius so it won't appear broken
-     */
-    arrowPadding?: number;
-    /**
-     * Guides to the browser as to the type of information expected in the field.
-     */
-    autocomplete?: InputHTMLAttributes['autocomplete'];
-    /**
-     * Sets autofocus on page load.
-     */
-    autofocus?: InputHTMLAttributes['autofocus'];
-    /**
-     * Displays the component as full width.
-     */
-    block?: boolean;
-    /**
-     * Defines the input as checked
-     */
-    checked?: InputHTMLAttributes['checked'];
-    /**
-     * Define a color for the component.
-     *
-     * Either a custom color or a coded color in common HEX, RGB, etc... format.
-     */
-    color?: string;
-    /**
-     * Adds a CSS class that applies a compact style to the component.
-     */
-    compact?: boolean;
-    /**
-     * Visually hidden string used to label the close button.
-     */
-    closeLabel?: string;
-    /**
-     * Defines an array of dependencies that will trigger actions in the component upon change.
-     */
-    dependencies?: any[];
-    /**
-     * Timeout used to debounce response to changes to dependencies.
-     */
-    depsDebounceTime?: number;
-    /**
-     * Direction of the layout of the component. Can either be a predefined value or a pattern separated by a space like `xx xxxxx`.
-     */
-    direction?: 'horizontal' | 'vertical' | 'auto' | string;
-    /**
-     * Disables the component
-     */
-    disabled?: boolean;
-    /**
-     * Prevents rendering content before it's made visible.
-     */
-    eager?: boolean;
-    /**
-     * If coherence is enforce the input cannot have a modelValue the is incoherent with its current items.
-     *
-     * e.g. You cannot set v-model to a user that is not present in the items passed.
-     *
-     * modelValue will be reset upon incoherence.
-     */
-    enforceCoherence?: boolean;
-    /**
-     * Can be a string or an array of string containing the messages to display.
-     */
-    errors?: string | string[];
-    /**
-     * Value of the input when unchecked. It handles any kind of serializable object.
-     */
-    falseValue?: any;
-    /**
-     * Define if the component should be in an error state.
-     * It usually attaches a CSS class for styling purposes.
-     */
-    hasErrors?: boolean;
-    /**
-     * Visually hides the label of the input while maintaining accessibility.
-     */
-    hideLabel?: boolean;
-    /**
-     * Visually hides the legend of the fieldset while maintaining accessibility.
-     */
-    hideLegend?: boolean;
-    /**
-     * The identifier of the component.
-     */
-    id?: HTMLAttributes['id'];
-    /**
-     * Defines the direction of the inputs in the fieldset
-     */
-    inputDirection?: 'horizontal' | 'vertical';
-    /**
-     * Sets the slignment of the input. Since inputs are inline block they can be aligned just as text can.
-     */
-    inputPosition?: 'left' | 'center' | 'right';
-    /**
-     * Sets the input in an indeterminate state.
-     */
-    indeterminate?: InputHTMLAttributes['indeterminate'];
-    /**
-     * Getter used to retrieve a label from the item.
-     *
-     * Can be a path that will be walked to a value e.g. `address.city` will retrieve the value at `item.address.city`.
-     *
-     * Can be a function that accept an item and returns a string.
-     */
-    itemText?: string | ((item: any) => string);
-    /**
-     * Getter used to retrieve a value from the item.
-     *
-     * Can be a path that will be walked to a value e.g. `address.city` will retrieve the value at `item.address.city`.
-     *
-     * Can be a function that accept an item and returns a value.
-     */
-    itemValue?: string | ((item: any) => any);
-    /**
-     * Text content of the label of the element.
-     */
-    label: string;
-    /**
-     * Sets the text alignment of the label.
-     */
-    labelPosition?: 'left' | 'center' | 'right';
-    /**
-     * Text content of the legend.
-     */
-    legend: string;
-    /**
-     * Sets the text alignment of the legend.
-     */
-    legendPosition?: 'left' | 'center' | 'right';
-    /**
-     * Sets the component in a loading state, usually triggering some visual styles.
-     */
-    loading?: boolean;
-    /**
-     * String displayed while items are being loaded.
-     */
-    loadingText?: string;
-    /**
-     * Timeout used to debounce response to changes to modelValue.
-     */
-    modelValueDebounceTime?: number;
-    /**
-     * Allows the selection of multiple items.
-     */
-    multiple?: boolean;
-    /**
-     * Defines the name of the input.
-     */
-    name?: InputHTMLAttributes['name'];
-    /**
-     * String displayed when there are no items to display.
-     */
-    noDataText?: string;
-    /**
-     * Space the floating container will maintain from the activator.
-     */
-    offset?: number;
-    /**
-     * CSS classes to apply to the overlay.
-     */
-    overlayClasses?: Classes;
-    /**
-     * Minimum empty space to keep from the edge of the page
-     */
-    padding?: number;
-    /**
-     * CSS classes to apply to the panel of the component.
-     */
-    panelClasses?: Classes;
-    /**
-     * Prevents closing by clicking on the overlay. It does NOT prevent closing by clicking on the close button.
-     */
-    persistent?: boolean;
-    /**
-     * String displayed when there's no data.
-     */
-    placeholder?: InputHTMLAttributes['placeholder'];
-    /**
-     * Position of the overlay in respect to the related activator.
-     */
-    placement?: 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';
-    /**
-     * Sets the input in a readonly state.
-     */
-    readonly?: boolean;
-    /**
-     * Reverses the layout. Applicable in every direction the order of the label and the input is swapped.
-     */
-    reverse?: boolean;
-    /**
-     * Defines whether to show the close button.
-     */
-    showClose?: boolean;
-    /**
-     * Will submit "falseValue" if the input is not checked. Otherwise "trueValue" will be submitted.
-     */
-    submitWhenFalse?: boolean;
-    /**
-     * Value of the input when checked. It handles any kind of serializable object.
-     */
-    trueValue?: any;
-    /**
-     * Text content of the component.
-     */
-    text?: string;
-    /**
-     * Name of the theme to apply to the component. It creates a CSS class with the name of the theme.
-     */
-    theme?: string;
-    /**
-     * Assigns a title to the element. This also helps accessibility.
-     */
-    title?: string;
-    /**
-     * Defines which transition is applied. It attaches a CSS class with the name of the transition.
-     */
-    transition?: string;
-    /**
-     * How long the transition has to last in milliseconds
-     */
-    transitionDuration?: number;
-};
-export type GenericModelValue = {
-    /**
-     * Used by v-model. Can be any serializable type.
-     */
-    modelValue?: any;
-};
-export type GenericModelValueArray = {
-    /**
-     * Used by v-model. Can be an array of any serializable type.
-     */
-    modelValue?: any[];
-};
-export type NonVoidElementTag = {
-    /**
-     * Any HTML tag corresponding to a non-void HTMl element.
-     */
-    tag?: keyof Omit<HTMLElementTagNameMap, VoidHTMLElements>;
-};
-export type OptionItems<T = any> = {
-    /**
-     * Used to retrieve items can be an array or a function.
-     */
-    items: T[] | ((prefill: boolean, modelValue?: any[]) => Promise<T[]>) | ((prefill: boolean, modelValue?: any[]) => T[]);
-};
-export type OptionItemsWithQuery<T = any> = {
-    /**
-     * Used to retrieve items can be an array or a function.
-     */
-    items: T[] | ((query: string, prefill: boolean, modelValue: any) => Promise<T[]>) | ((query: string, prefill: boolean, modelValue: any) => T[]);
-};
-export type ItemText<T> = {
-    /**
-     * Defines a path that returns a property of the object to use as text or a function that returns a string
-     */
-    itemText?: T extends object ? NestedKeyOf<T> | ((item: T) => string) : ((item: T) => string) | undefined;
-};
-export type ItemValue<T> = {
-    /**
-     * Defines a path that returns a property of the object to use as value or a function that returns any value
-     */
-    itemValue?: T extends object ? NestedKeyOf<T> | ((item: T) => string) : ((item: T) => any) | undefined;
+import { ComponentPublicInstance } from 'vue';
+/**
+ * An external element reference prop (activator/anchor): a DOM element, a Vue
+ * component instance (its root element is resolved internally), or `null`.
+ *
+ * The `Pick<…, '$el'>` arm keeps concretely typed component instances
+ * assignable: instances with typed `$emit` signatures are not assignable to
+ * the base `ComponentPublicInstance` type, but all of them expose `$el`,
+ * which is what the internal DOM resolution consumes.
+ */
+export type ElementOrComponentRef = HTMLElement | ComponentPublicInstance | Pick<ComponentPublicInstance, '$el'> | null;
+/**
+ * Variant of {@link ElementOrComponentRef} for boundary props, which
+ * additionally accept a CSS selector string.
+ */
+export type ElementOrComponentRefOrSelector = ElementOrComponentRef | string;
+/**
+ * Element choices for a purely structural wrapper (BbSmoothHeight, BbDropzone).
+ * The wrapper carries layout and nothing else, so the only meaningful choice is
+ * block vs inline.
+ */
+export type LayoutTag = 'div' | 'span';
+/**
+ * Element choices for the plain (non-link, non-router) button branch.
+ *
+ * - `button` — the default; real button semantics and keyboard behavior
+ * - `div` / `span` — a clickable box nested inside another button or link,
+ *   where a nested `<button>` would be invalid markup
+ * - `label` — a file-upload trigger wrapping a visually hidden `<input>`
+ *
+ * `a` is deliberately absent: `href`/`to` already route to the anchor branch.
+ */
+export type ButtonTag = 'button' | 'div' | 'span' | 'label';
+/**
+ * Element choices for an input container's outer wrapper: inline by default,
+ * `fieldset` for grouped controls, `label` when the whole container should
+ * activate the control.
+ */
+export type ContainerTag = 'span' | 'div' | 'fieldset' | 'label';
+/**
+ * Element choices for an input container's label element: `label` for a single
+ * control, `legend` inside a `fieldset`, `span` when the text must not steal
+ * the click (the control already owns its own label).
+ */
+export type LabelTag = 'label' | 'legend' | 'span';
+/**
+ * Element choices for a floating popover wrapper. The wrapper is
+ * `position: fixed` either way, so this only decides markup validity: `div`
+ * (the default) is correct wherever the popover holds block content, `span`
+ * for the rare mount point that only accepts phrasing content.
+ */
+export type PopoverTag = 'div' | 'span';
+/**
+ * Mixin carrying the wrapper `tag` prop for structural components.
+ */
+export type LayoutElementTag = {
+    /**
+     * Element rendered as the component's wrapper.
+     */
+    tag?: LayoutTag;
 };
 export type Size<T> = {
     /**
-     * Defines a dimension for the component
+     * Defines the component size.
+     *
+     * Accepted values:
+     * - A key from the provided size map (`keyof T`), e.g. `'sm' | 'md' | 'lg'`
+     * - A custom CSS size string (e.g. `'20px'`, `'1.5rem'`, `'2em'`)
+     * - A number, typically interpreted as pixels by size parsers
      */
     size?: keyof T | ({
         size?: any;
     } & string) | number;
 };
-export {};

package/dist/types/Config.d.ts

@@ -0,0 +1,84 @@
+import { Sizes } from './SizeScale';
+import { BbToastPosition } from '../components/BbToast/types';
+import { BuiltinLocaleKey, CustomLocales, LocaleKey, LocaleOverrides } from '../i18n';
+export type { Sizes as DialogSizes };
+export type { BuiltinLocaleKey, CustomLocales, LocaleKey, LocaleOverrides };
+export type InputLabelMode = 'outside' | 'floating' | 'inside';
+export type EditableConfig = {
+    inertiaLinkName: string;
+    nuxtLinkName: string;
+    linkActiveClass: string;
+    linkExactActiveClass: string;
+    mobileMaxWidth: number;
+    /**
+     * Viewport width (px) the library assumes while rendering on the **server**,
+     * where the real screen size is unknowable. Defaults to `1024` — a desktop
+     * width — so server output is desktop-first. On the client the real
+     * `window.innerWidth` is used from the first paint, so client-only SPAs are
+     * unaffected by this option.
+     *
+     * To make a server-rendered app's mobile first paint match the device (rather
+     * than rendering desktop-shaped and adjusting once the client measures), feed
+     * this a real width per request from a cookie your client sets once (see the
+     * SSR viewport guide). The library never reads cookies or sniffs the
+     * User-Agent itself — it only uses the number you provide.
+     */
+    ssrViewportWidth: number;
+    /**
+     * Default for the `adaptive` prop of surface components (BbDialog, BbPopover,
+     * BbDropdown, BbSelect). When true, those components open as a bottom off-canvas
+     * sheet on mobile instead of their floating surface. Overridable per component
+     * via the `adaptive` prop (an explicit value always wins over this default).
+     */
+    adaptive: boolean;
+    locale: LocaleKey;
+    /**
+     * **Additional** locale dictionaries, keyed by locale. Built-in locales
+     * cannot be overridden — a built-in key here is a type error and is
+     * ignored (with a build-time warning) by the plugin. The plugin registers
+     * each key in `LocaleRegistry` (generated `locale-registry.d.ts`) so it is
+     * selectable via `locale` / `setConfig({ locale })`, wires the matching
+     * `dayjs/locale/<key>` for calendars when one exists (build-time warning +
+     * English calendar otherwise), and verifies each dictionary against the
+     * library's English template — a library upgrade that adds new string keys
+     * surfaces as a build-time warning listing what your translation is
+     * missing. Missing keys fall back per-key to the default locale until
+     * translated. Generate a translation blueprint with
+     * `npx bitboss-ui locale <key>`.
+     */
+    additionalLocales: CustomLocales;
+    injectStyles: boolean;
+    resetCss: boolean;
+    injectDirectives: boolean;
+    /**
+     * When `true`, form controls render a red asterisk next to the label/legend
+     * of `required` fields. Off by default. Purely presentational — it keys off
+     * the standard `required` prop and does not change validation or native
+     * `required` semantics.
+     */
+    requiredAsterisk: boolean;
+    defaultInputLabelMode: InputLabelMode;
+    iconDefaultSizes: Partial<Sizes>;
+    dialogDefaultSizes: Partial<Sizes>;
+    offCanvasDefaultSizes: Partial<Sizes>;
+    /**
+     * Default viewport corner toasts render in when neither the toast nor the
+     * `<BbToast>` host specify one.
+     */
+    toastPosition: BbToastPosition;
+};
+export type ResolvedConfig = Omit<EditableConfig, 'iconDefaultSizes' | 'dialogDefaultSizes' | 'offCanvasDefaultSizes'> & {
+    iconDefaultSizes: Sizes;
+    dialogDefaultSizes: Sizes;
+    offCanvasDefaultSizes: Sizes;
+    /**
+     * The per-key fallback anchor for string lookups, resolved by the plugin:
+     * the `locale` option when it is a built-in, otherwise `'en'`. Always among
+     * the enabled (bundled) locales; not consumer-settable.
+     */
+    defaultLocale: BuiltinLocaleKey;
+};
+/**
+ * The runtime-settable slice of the config (`setConfig`).
+ */
+export type DynamicConfig = Pick<EditableConfig, 'locale'>;

package/dist/types/ConfirmVariant.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Empty hook interface for module augmentation by the vite plugin.
+ * @internal
+ */
+export interface ConfirmVariantRegistry {
+}
+export type ConfirmVariantFromRegistry = keyof ConfirmVariantRegistry;
+/**
+ * Variant type for `BbConfirmMessage.variant`.
+ *
+ * Locked to registered variants — the built-in set plus any added via the vite
+ * plugin `confirmVariants` option — so unknown names are a compile error. For a
+ * one-off, register it (recommended) or force it with a cast.
+ */
+export type ConfirmVariantType = ConfirmVariantFromRegistry;

package/dist/types/DropdownItemVariant.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Empty hook interface for module augmentation by the vite plugin.
+ * @internal
+ */
+export interface DropdownItemVariantRegistry {
+}
+export type DropdownItemVariantFromRegistry = keyof DropdownItemVariantRegistry;
+/**
+ * Variant type for a dropdown `Item.variant`.
+ *
+ * Locked to registered variants — the built-in set plus any added via the vite
+ * plugin `dropdownItemVariants` option — so unknown names are a compile error.
+ * Out of the box only `destructive` carries styling; `default` is the unstyled
+ * baseline. For a one-off, register it (recommended) or force it with a cast: the
+ * class `bb-dropdown__item--variant-<variant>` is interpolated at runtime, so your
+ * CSS still applies.
+ */
+export type DropdownItemVariantType = DropdownItemVariantFromRegistry;

package/dist/types/Icon.d.ts

@@ -1,9 +1,7 @@
 /**
- * Create an empty interface to serve as a "hook" for users.
- * @internal This interface is meant for module augmentation only.
- * It should not be used directly by library consumers.
+ * Icon name — any Iconify name, e.g. `lucide:check`.
+ *
+ * Deliberately just `string`: the registry-augmentation approach was dropped.
+ * Autocomplete comes from the Iconify editor extension, not the type system.
  */
-export interface IconRegistry {
-}
-export type IconNameFromRegistry = keyof IconRegistry;
-export type IconType = IconNameFromRegistry | (string & {});
+export type IconType = string;

package/dist/types/IndicatorVariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Empty hook interface for module augmentation by the vite plugin.
+ * @internal
+ */
+export interface IndicatorVariantRegistry {
+}
+export type IndicatorVariantFromRegistry = keyof IndicatorVariantRegistry;
+/**
+ * Variant type for a `BbIndicator`'s `variant`.
+ *
+ * Locked to registered variants — the built-in set plus any added via the vite
+ * plugin `indicatorVariants` option — so unknown names are a compile error. For a
+ * one-off, register it (recommended) or force it with a cast: the class
+ * `bb-indicator--<variant>` is interpolated at runtime, so your CSS still applies.
+ */
+export type IndicatorVariantType = IndicatorVariantFromRegistry;

package/dist/types/InputDirection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Layout direction of a form field.
+ *
+ * - `'auto'` — natural sizes, no width constraints
+ * - `'vertical'` — label above the control, both full width
+ * - `'horizontal'` — label and control side by side, 50/50
+ * - a two-word pattern (e.g. `'xx xxxxxx'`) — side by side, with the label /
+ *   control width ratio taken from the two word lengths (here 2:6 → 25%/75%)
+ *
+ * The template-literal member keeps the keywords autocompletable while still
+ * accepting patterns; single-word typos are rejected at compile time. Patterns
+ * of three or more tokens cannot be excluded by the type — those fall through
+ * to the runtime check, which warns and falls back to 'auto'.
+ */
+export type InputDirection = 'auto' | 'horizontal' | 'vertical' | `${string} ${string}`;

package/dist/types/ItemAccessor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Accessor for a field on an item: a top-level key (autocompleted), any
+ * dot-path string (accepted, resolved at runtime), or a getter function.
+ *
+ * Deliberately NOT a recursive `NestedKeyOf<T>` path type. That is O(number
+ * of paths) to instantiate and blows up ("type instantiation is excessively
+ * deep") on the deep / generated API shapes real apps pass, with unreadable
+ * errors. Top-level-key autocomplete covers the common case; deeper dot-paths
+ * still work, just unchecked — the same trade-off as the variant registries.
+ *
+ * `R` is the getter's return type: `string` for text accessors, `any` for
+ * value accessors. When `T` is `any` this degrades to `string | ((item) => R)`.
+ *
+ * Non-conditional on purpose: a `T extends object ? … : …` form is opaque to
+ * the checker when `T` is an unconstrained generic (a plain `string` can't be
+ * assigned to a deferred conditional). The `(string & {})` member already
+ * accepts any string — including the harmless method-name keys that
+ * `keyof T & string` yields for primitive `T` — so the flat union covers both
+ * object and primitive items while staying assignable through generic wrappers.
+ */
+export type ItemAccessor<T, R = any> = (keyof T & string) | (string & {}) | ((item: T) => R);

package/dist/types/Placement.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Position of a floating overlay relative to its anchor. Matches
+ * `@floating-ui`'s placement vocabulary, declared locally so the public API
+ * does not leak the dependency's types.
+ */
+export type Placement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';

package/dist/types/ResponsiveSize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Named breakpoints, matching the `min-width` thresholds baked into component
+ * CSS (Tailwind's scale: sm 640, md 768, lg 1024, xl 1280, 2xl 1536). The
+ * `default` key is the base, applied below the first breakpoint.
+ */
+export type Breakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+/**
+ * A value applied at every viewport, or a per-breakpoint map that switches at
+ * the thresholds above. Each size family plugs in its own value type `V`, so
+ * the responsive *mechanism* is shared while the size *vocabulary* stays
+ * distinct per component (a dialog width means something different from a
+ * button size).
+ *
+ * @example
+ * ```ts
+ * size="md"                          // one value everywhere
+ * :size="{ default: 'sm', lg: 'lg' }" // sm below 1024px, lg at/above
+ * ```
+ */
+export type Responsive<V> = V | Partial<Record<Breakpoint | 'default', V>>;

package/dist/types/SizeScale.d.ts

@@ -0,0 +1,8 @@
+export type Sizes = {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    '2xl': number;
+};

package/dist/types/ToastVariant.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Empty hook interface for module augmentation by the vite plugin.
+ * @internal
+ */
+export interface ToastVariantRegistry {
+}
+export type ToastVariantFromRegistry = keyof ToastVariantRegistry;
+/**
+ * Variant type for a toast's `variant`.
+ *
+ * Locked to registered variants — the built-in set plus any added via the vite
+ * plugin `toastVariants` option — so unknown names are a compile error. For a
+ * one-off, register it (recommended) or force it with a cast: the class
+ * `bb-toast-message--<variant>` is interpolated at runtime, so your CSS still
+ * applies.
+ */
+export type ToastVariantType = ToastVariantFromRegistry;

package/dist/types/TooltipVariant.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Empty hook interface for module augmentation by the vite plugin.
+ * @internal
+ */
+export interface TooltipVariantRegistry {
+}
+export type TooltipVariantFromRegistry = keyof TooltipVariantRegistry;
+/**
+ * Variant type for `BbTooltip.variant`.
+ *
+ * Locked to registered variants — the built-in set plus any added via the vite
+ * plugin `tooltipVariants` option — so unknown names are a compile error. Out of
+ * the box `default` is the inverted (primary) bubble and `destructive` the
+ * danger-tinted one. For a one-off, register it (recommended) or force it with a
+ * cast: the class `bb-tooltip--<variant>` is interpolated at runtime, so your CSS
+ * still applies.
+ */
+export type TooltipVariantType = TooltipVariantFromRegistry;

package/dist/utilities/functions/bytesToUnit.d.ts

@@ -0,0 +1,2 @@
+/** Formats a byte count into a human-readable size string (e.g. `1.5 MB`). */
+export declare const bytesToUnit: (bytes: number, decimals?: number) => string;

package/dist/utilities/functions/bytesToUnit.js

@@ -0,0 +1,18 @@
+//#region src/utilities/functions/bytesToUnit.ts
+var e = (e, t = 2) => {
+	if (!e) return "0 B";
+	let n = 1024, r = t || 0, i = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB",
+		"EB",
+		"ZB",
+		"YB"
+	], a = Math.floor(Math.log(e) / Math.log(n));
+	return parseFloat((e / n ** a).toFixed(r)) + " " + i[a];
+};
+//#endregion
+export { e as bytesToUnit };

package/dist/utilities/functions/clampPrecision.js

@@ -0,0 +1,10 @@
+//#region src/utilities/functions/clampPrecision.ts
+var e = (e, t) => {
+	if (e.endsWith(".")) return t === 0 ? e.slice(0, -1) : e;
+	let [n, r] = e.split(".");
+	if (!r) return e;
+	let i = r.slice(0, t);
+	return i ? `${n}.${i}` : n;
+};
+//#endregion
+export { e as clampPrecision };