nuance-ui 0.2.5 → 0.2.7

package/dist/runtime/utils/{create-variant-color-resolver.js → style/create-variant-color-resolver.js}

@@ -1,6 +1,6 @@
-import { DEFAULT_GRADIENT } from "../const/index.js";
-import { getGradient, getGradientOutline } from "./color-functions/get-gradient.js";
-import { getThemeColor, parseThemeColor } from "./color-functions/parse-theme-color.js";
+import { DEFAULT_GRADIENT } from "../color/const.js";
+import { getGradient, getGradientOutline } from "../color/get-gradient.js";
+import { getThemeColor, parseThemeColor } from "../color/parse-theme-color.js";
 export function createVariantColorResolver({
   color = "primary",
   variant,

package/dist/runtime/utils/style/index.d.ts

@@ -0,0 +1 @@
+export * from './create-variant-color-resolver.js';

package/dist/runtime/utils/style/index.js

@@ -0,0 +1 @@
+export * from "./create-variant-color-resolver.js";

package/dist/runtime/utils/tree.d.ts

@@ -1,107 +1,43 @@
-/** Represents a tree node with a value and optional children. */
+/** Node of a generic string-keyed tree. */
 export interface TreeNode<T extends string = string> {
-    /** The value stored in this tree node */
+    /** Path-like identifier of the node. */
     path: string;
-    /** Optional array of child nodes */
+    /** Child nodes of this node. */
     children?: TreeNode<T>[];
 }
 /**
- * Filters tree nodes based on a predicate function.
- * Returns a new tree containing only nodes that match the predicate.
- * Parent nodes are kept if they have matching children.
+ * Returns a new tree containing only the nodes that match the predicate.
  *
- * @template Node - The type of tree nodes
- * @param {Node[]} tree - The tree to filter
- * @param {(node: Node) => boolean} predicate - Function to test each node
- * @returns {Node[]} New filtered tree
- * @example
- * const tree = [
- *   { value: 'folder', children: [{ value: 'file1' }, { value: 'file2' }] },
- *   { value: 'file3' }
- * ]
- * // Keep only folders (nodes with children)
- * filterTree(tree, node => node.children && node.children.length > 0)
- * // Result: [{ value: 'folder', children: [{ value: 'file1' }, { value: 'file2' }] }]
+ * A parent is kept whenever at least one of its (recursively filtered)
+ * descendants matches, even if the parent itself does not.
  */
 export declare function filterTree<Node extends TreeNode = TreeNode>(tree: Node[], predicate: (node: Node) => boolean): Node[];
 /**
- * Searches for a tree item by its value using depth-first search.
- * @template T - The type of node values
- * @param {TreeNode<T>[]} items - The array of tree nodes to search in
- * @param {T} path - The value to search for
- * @returns {TreeNode<T> | null} The found node or null if not found
- * @example
- * const tree = [{ value: 'folder', children: [{ value: 'file' }] }]
- * findTreeItem(tree, 'file') // { value: 'file' }
- * findTreeItem(tree, 'missing') // null
+ * Finds a tree node by its `path` using depth-first search.
+ *
+ * Returns `null` when no matching node exists.
  */
 export declare function findTreeItem<T extends string = string>(items: TreeNode<T>[], path: T): TreeNode<T> | null;
-/**
- * Flattens a tree structure into a single-level array in depth-first order.
- * @template T - The type of node values
- * @param {TreeNode<T>[]} tree - The tree to flatten
- * @returns {TreeNode<T>[]} Flattened array containing all nodes
- * @example
- * const tree = [
- *   { value: 'root', children: [
- *     { value: 'child1' },
- *     { value: 'child2' }
- *   ]}
- * ]
- * flatTree(tree) // [{ value: 'root', ... }, { value: 'child1' }, { value: 'child2' }]
- */
+/** Flattens a tree into a single array in depth-first order. */
 export declare function flatTree<T extends string = string>(tree: TreeNode<T>[]): TreeNode<T>[];
 /**
- * Gets all descendant values of a specific node in the tree.
+ * Returns all descendant paths of the node with the given `path`.
  *
- * @template T - The type of node values
- * @param {TreeNode<T>[]} tree - The tree to search in
- * @param {T} path - The path of the parent node
- * @returns {T[]} Array of all descendant values (empty if node not found or has no children)
- * @example
- * const tree = [
- *   { value: 'folder', children: [
- *     { value: 'file1' },
- *     { value: 'subfolder', children: [{ value: 'file2' }] }
- *   ]}
- * ]
- * getBranchChildren(tree, 'folder') // ['file1', 'subfolder', 'file2']
- * getBranchChildren(tree, 'file1') // []
+ * The result is empty when the node is not found or has no children.
  */
 export declare function getBranchChildren<T extends string = string>(tree: TreeNode<T>[], path: T): T[];
 /**
- * Gets all node values between two specified values (inclusive) in tree traversal order.
- * If start comes after end in traversal order, the range is automatically reversed.
- * Uses a single-pass algorithm that flattens and searches simultaneously.
- * @template T - The type of node values
- * @param {TreeNode<T>[]} tree - The tree to search in
- * @param {T} start - The starting value
- * @param {T} end - The ending value
- * @returns {T[]} Array of values between start and end (inclusive), empty if either value not found
- * @example
- * const tree = [
- *   { value: 'a', children: [{ value: 'b' }, { value: 'c' }] },
- *   { value: 'd' }
- * ]
- * getItemsBetween(tree, 'b', 'd') // ['b', 'c', 'd']
- * getItemsBetween(tree, 'd', 'b') // ['b', 'c', 'd'] (auto-reversed)
- * getItemsBetween(tree, 'a', 'missing') // []
+ * Returns all node paths between `start` and `end` (inclusive) in
+ * depth-first traversal order.
+ *
+ * If `start` comes after `end` in traversal order, the range is
+ * automatically reversed. Returns an empty array when either endpoint is
+ * missing.
  */
 export declare function getTreeItemsBetween<T extends string = string>(tree: TreeNode<T>[], start: T, end: T): T[];
 /**
- * Removes nodes with specified values from the tree, including their subtrees.
- * Returns a new tree without modifying the original.
+ * Returns a new tree with the given paths and their subtrees removed.
  *
- * @template T - The type of node path
- * @param {TreeNode<T>[]} tree - The original tree (array of root nodes)
- * @param {T[]} valuesToRemove - Array of values to remove
- * @returns {TreeNode<T>[]} New tree with specified nodes and their subtrees removed
- * @example
- * const tree = [
- *   { value: 'a', children: [{ value: 'b' }, { value: 'c' }] },
- *   { value: 'd' }
- * ]
- * removeTreeNodes(tree, ['b', 'd']) // [{ value: 'a', children: [{ value: 'c' }] }]
- * removeTreeNodes(tree, ['a']) // [{ value: 'd' }]
+ * The input tree is not mutated.
  */
 export declare function removeTreeNodes<Node extends TreeNode = TreeNode, Path extends string = string>(tree: Node[], valuesToRemove: Path[]): Node[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nuance-ui",
-	"version": "0.2.5",
+	"version": "0.2.7",
 	"description": "A modern Vue UI library inspired by the best of the React ecosystem.",
 	"repository": {
 		"type": "git",
@@ -13,9 +13,9 @@
 			"types": "./dist/types.d.mts",
 			"import": "./dist/module.mjs"
 		},
-		"./composals": {
-			"types": "./dist/runtime/composals/index.d.ts",
-			"import": "./dist/runtime/composals/index.js"
+		"./composables": {
+			"types": "./dist/runtime/composables/index.d.ts",
+			"import": "./dist/runtime/composables/index.js"
 		},
 		"./components": {
 			"types": "./dist/runtime/components/index.d.ts",
@@ -25,10 +25,6 @@
 			"types": "./dist/runtime/modals/index.d.ts",
 			"import": "./dist/runtime/modals/index.js"
 		},
-		"./helpers": {
-			"types": "./dist/runtime/helpers/index.d.ts",
-			"import": "./dist/runtime/helpers/index.js"
-		},
 		"./utils": {
 			"types": "./dist/runtime/utils/index.d.ts",
 			"import": "./dist/runtime/utils/index.js"
@@ -51,7 +47,7 @@
 		"dev:build": "nuxi build playground",
 		"dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
 		"release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
-		"lint": "eslint .",
+		"lint": "eslint ./src",
 		"test": "vitest run",
 		"test:watch": "vitest watch",
 		"test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"

package/dist/runtime/components/combobox/lib/use-combobox/use-combobox.d.ts

@@ -1,70 +0,0 @@
-import type { ModelRef, ShallowRef } from 'vue';
-import type { ComboboxDropdownEventSource } from '../../types/index.js';
-import type { ComboboxAttrs } from '../const.js';
-export interface ComboboxStore {
-    /** Id passed to dropdown */
-    listId: string;
-    /** Opens dropdown */
-    openDropdown: (eventSource?: ComboboxDropdownEventSource) => void;
-    /** Closes dropdown */
-    closeDropdown: (eventSource?: ComboboxDropdownEventSource) => void;
-    /** Toggles dropdown opened state */
-    toggleDropdown: (eventSource?: ComboboxDropdownEventSource) => void;
-    /** Returns currently selected option index or `-1` if none of the options is selected */
-    getSelectedOptionIx: () => number;
-    /** Selects `Combobox.Option` by index */
-    selectOption: (index: number) => void;
-    /**
-     * Selects first `Combobox.Option` with `active` prop.
-     *  If there are no such options, the function does nothing.
-     */
-    selectActiveOption: () => string | null;
-    /**
-     * Selects first `Combobox.Option` that is not disabled.
-     *  If there are no such options, the function does nothing.
-     */
-    selectFirstOption: () => string | null;
-    /**
-     * Selects next `Combobox.Option` that is not disabled.
-     *  If the current option is the last one, the function selects first option, if `loop` is true.
-     */
-    selectNextOption: () => string | null;
-    /**
-     * Selects previous `Combobox.Option` that is not disabled.
-     *  If the current option is the first one, the function selects last option, if `loop` is true.
-     */
-    selectPrevOption: () => string | null;
-    /** Resets selected option index to -1, removes `data-combobox-selected` from selected option */
-    resetSelectedOption: () => void;
-    /**
-     * Triggers `onClick` event of selected option.
-     *  If there is no selected option, the function does nothing.
-     */
-    clickSelectedOption: () => void;
-    /**
-     * Updates selected option index to currently selected or active option.
-     *  The function is required to be used with searchable components to update selected option index
-     *  when options list changes based on search query.
-     */
-    updateSelectedOptionIx: (target?: 'active' | 'selected', options?: {
-        scrollIntoView?: boolean;
-    }) => void;
-    /** Ref of `Combobox.Search` input */
-    searchRef: ShallowRef<HTMLInputElement | null>;
-    /** Moves focus to `Combobox.Search` input */
-    focusSearch: () => void;
-    /** Ref of the target element */
-    targetRef: ShallowRef<HTMLElement | null>;
-    /** Moves focus to the target element */
-    focusTarget: () => void;
-}
-export declare function useCombobox({ onSelect, onClear, onCloseDropdown, onOpenDropdown, opened, ..._options }: {
-    attrs?: ComboboxAttrs;
-    scrollBehavior?: ScrollBehavior;
-    loop?: boolean;
-    onSelect?: (ix: number) => void;
-    onClear?: () => void;
-    onOpenDropdown?: (eventSource: ComboboxDropdownEventSource) => void;
-    onCloseDropdown?: (eventSource: ComboboxDropdownEventSource) => void;
-    opened: ModelRef<boolean>;
-}): ComboboxStore;

package/dist/runtime/components/combobox/lib/use-combobox/use-combobox.js

@@ -1,97 +0,0 @@
-import { unrefElement } from "@vueuse/core";
-import { nextTick, shallowRef, useId } from "vue";
-import { COMBOBOX_ATTRS } from "../const.js";
-import {
-  clearSelected,
-  selectActiveOption,
-  selectFirstOption,
-  selectNextOption,
-  selectOption,
-  selectPrevOption,
-  updateSelectedOptionIx
-} from "./handlers.js";
-export function useCombobox({ onSelect, onClear, onCloseDropdown, onOpenDropdown, opened, ..._options }) {
-  const listId = useId();
-  const targetRef = shallowRef(null);
-  const searchRef = shallowRef(null);
-  const openDropdown = (eventSource = "unknown") => {
-    if (!opened.value) {
-      opened.value = true;
-      onOpenDropdown?.(eventSource);
-    }
-  };
-  const closeDropdown = (eventSource = "unknown") => {
-    if (opened.value) {
-      opened.value = false;
-      onCloseDropdown?.(eventSource);
-    }
-  };
-  const toggleDropdown = (eventSource = "unknown") => {
-    if (opened.value)
-      closeDropdown(eventSource);
-    else
-      openDropdown(eventSource);
-  };
-  const options = {
-    attrs: _options?.attrs ?? COMBOBOX_ATTRS,
-    scrollBehavior: _options?.scrollBehavior ?? "instant",
-    loop: _options?.loop ?? true,
-    listId,
-    selectFn: (ix) => ix ? `${ix}` : null
-  };
-  let selectedOptionIx = -1;
-  const getSelectedIx = () => selectedOptionIx;
-  const clear = () => {
-    clearSelected(options);
-    onClear?.();
-  };
-  const select = (ix) => {
-    const res = selectOption(ix, { ...options, clearFn: clear });
-    if (res) {
-      selectedOptionIx = res.ix;
-      onSelect?.(res.ix);
-      return res.value;
-    }
-    return null;
-  };
-  options.selectFn = select;
-  const selectActive = () => selectActiveOption(options);
-  const selectNext = () => selectNextOption(getSelectedIx(), options);
-  const selectPrev = () => selectPrevOption(getSelectedIx(), options);
-  const selectFirst = () => selectFirstOption(options);
-  const updateSelectedIx = (target) => updateSelectedOptionIx(target, options);
-  const resetSelectedOption = () => {
-    selectedOptionIx = -1;
-    clear();
-  };
-  const clickSelectedOption = () => {
-    const items = document.querySelectorAll(`#${options.listId} [${options.attrs.option}]`);
-    const item = items?.[selectedOptionIx];
-    item?.click();
-  };
-  const focusSearch = () => {
-    nextTick(() => unrefElement(searchRef)?.focus());
-  };
-  const focusTarget = () => {
-    nextTick(() => unrefElement(targetRef)?.focus());
-  };
-  return {
-    listId,
-    openDropdown,
-    closeDropdown,
-    toggleDropdown,
-    selectOption: select,
-    selectActiveOption: selectActive,
-    selectNextOption: selectNext,
-    selectPrevOption: selectPrev,
-    selectFirstOption: selectFirst,
-    resetSelectedOption,
-    clickSelectedOption,
-    getSelectedOptionIx: getSelectedIx,
-    targetRef,
-    focusTarget,
-    searchRef,
-    focusSearch,
-    updateSelectedOptionIx: updateSelectedIx
-  };
-}

package/dist/runtime/components/combobox/lib/use-combobox-data/use-combobox-data.d.ts

@@ -1,7 +0,0 @@
-import type { ComboboxData, ComboboxItem, ComboboxItemExt, ComboboxParsedItem } from '../../types/index.js';
-export declare function getOptionsLockup<Value extends string = string, Ext extends ComboboxItemExt = object>(options: ComboboxParsedItem<Value, Ext>[]): Record<string, ComboboxItem<Value, Ext>>;
-export declare function getLabelsLockup<Value extends string = string, Ext extends ComboboxItemExt = object>(options: ComboboxParsedItem<Value, Ext>[]): Record<string, string>;
-export declare function useComboboxData<Value extends string = string, Ext extends ComboboxItemExt = object>(data: ComboboxData<Value, Ext>): {
-    parsed: import("vue").ComputedRef<ComboboxParsedItem<Value, Ext>[]>;
-    options: import("vue").ComputedRef<Record<string, ComboboxItem<Value, Ext>>>;
-};

package/dist/runtime/components/combobox/lib/use-combobox-data/use-combobox-data.js

@@ -1,23 +0,0 @@
-import { computed } from "vue";
-import { getParsedComboboxData } from "./get-parsed-combobox-data.js";
-export function getOptionsLockup(options) {
-  return options.reduce((acc, item) => {
-    if ("group" in item)
-      return { ...acc, ...getOptionsLockup(item.items) };
-    acc[item.value] = item;
-    return acc;
-  }, {});
-}
-export function getLabelsLockup(options) {
-  return options.reduce((acc, item) => {
-    if ("group" in item)
-      return { ...acc, ...getLabelsLockup(item.items) };
-    acc[item.label] = item;
-    return acc;
-  }, {});
-}
-export function useComboboxData(data) {
-  const parsed = computed(() => getParsedComboboxData(data));
-  const options = computed(() => getOptionsLockup(parsed.value));
-  return { parsed, options };
-}

package/dist/runtime/components/combobox/lib/utils/is-options-group.d.ts

@@ -1,2 +0,0 @@
-import type { ComboboxItemExt, ComboboxParsedItem, ComboboxParsedItemGroup } from '../../types/index.js';
-export declare function isOptionsGroup<Value extends string = string, Ext extends ComboboxItemExt = object>(item: ComboboxParsedItem<Value, Ext>): item is ComboboxParsedItemGroup<Value, Ext>;

package/dist/runtime/components/combobox/types/index.d.ts

@@ -1,19 +0,0 @@
-import type { ComboboxItem, ComboboxItemExt, ComboboxItemGroup } from './item.js';
-export type ComboboxDropdownEventSource = 'keyboard' | 'mouse' | 'unknown';
-export type ComboboxData<Value extends string = string, Ext extends ComboboxItemExt = object> = (ComboboxItem<Value, Ext> | ComboboxItemGroup<Value, Ext>)[];
-export interface ComboboxRootEmits {
-    clear: [];
-    select: [number];
-    /** Called when dropdown opens with event source: keyboard, mouse or unknown */
-    open: [ComboboxDropdownEventSource];
-    /** Called when dropdown closes with event source: keyboard, mouse or unknown */
-    close: [ComboboxDropdownEventSource];
-    /** Called when item is selected with the `Enter` key or by clicking it */
-    submit: [string, ComboboxItem];
-}
-export interface ComboboxItemProps {
-    withCheckIcon?: boolean;
-    checkIcon?: string;
-    iconPosition?: 'left' | 'right';
-}
-export * from './item.js';

package/dist/runtime/components/combobox/types/index.js

@@ -1 +0,0 @@
-export * from "./item.js";

package/dist/runtime/components/combobox/types/item.d.ts

@@ -1,22 +0,0 @@
-interface BaseComboboxFields {
-    value: string;
-    label: string;
-    disabled?: boolean;
-    icon?: string;
-}
-export type ComboboxItemExt = Omit<object, keyof BaseComboboxFields>;
-export type ComboboxItem<Value extends string = string, Ext extends ComboboxItemExt = object> = BaseComboboxFields & {
-    value: Value;
-} & Ext;
-export interface ComboboxParsedItemGroup<Value extends string = string, Ext extends ComboboxItemExt = object> {
-    group: string;
-    icon?: string;
-    items: ComboboxItem<Value, Ext>[];
-}
-export type ComboboxParsedItem<Value extends string = string, Ext extends ComboboxItemExt = object> = ComboboxItem<Value, Ext> | ComboboxParsedItemGroup<Value, Ext>;
-export interface ComboboxItemGroup<Value extends string = string, Ext extends ComboboxItemExt = object> {
-    group: string;
-    icon?: string;
-    items: ComboboxItem<Value, Ext>[];
-}
-export {};

package/dist/runtime/components/select/index.d.ts

@@ -1 +0,0 @@
-export type * from './select.vue';

package/dist/runtime/components/transition/index.d.ts

@@ -1 +0,0 @@
-export type * from './transition.vue';

package/dist/runtime/composals/use-active-link.d.ts

@@ -1,5 +0,0 @@
-import type { ComputedRef } from 'vue';
-import type { RouteLocationRaw } from 'vue-router';
-export declare function useActiveLink(href: RouteLocationRaw | undefined, options?: {
-    exact?: boolean;
-}): ComputedRef<boolean>;

package/dist/runtime/composals/use-theme.d.ts

@@ -1,9 +0,0 @@
-import type { NuanceTheme } from '@nui/types';
-interface ThemeInstance {
-    preference: NuanceTheme;
-    readonly value: NuanceTheme;
-    unknown: boolean;
-    forced: boolean;
-}
-export declare function useTheme(): ThemeInstance;
-export {};

package/dist/runtime/helpers/create-strict-injection.d.ts

@@ -1,94 +0,0 @@
-import type { InjectionKey } from '@vue/runtime-core';
-import type { CreateInjectionStateOptions } from '@vueuse/core';
-interface StrictInjectionOptions<Return> extends Omit<CreateInjectionStateOptions<Return>, 'injectionKey'> {
-    /**
-     * The name of the context for error messages.
-     * Used to generate helpful error when context is missing.
-     *
-     * @example 'ComboboxState', 'FormContext', 'DialogProvider'
-     */
-    name: string;
-    injectionKey: InjectionKey<Return>;
-}
-type StrictInjectionReturn<Arguments extends Array<any>, Return> = Readonly<[
-    /**
-     * Provider function to be called in a parent component.
-     * Creates and provides the state to all descendant components.
-     *
-     * @param args - Arguments passed to the composable function
-     * @returns The state returned by the composable
-     *
-     * @example
-     * ```vue
-     * <script setup>
-     * const state = useProvideComboboxState({ items: [] })
-     * </script>
-     * ```
-     */
-    useProvidingState: (...args: Arguments) => Return,
-    /**
-     * Consumer function to be called in a child component.
-     * Injects the state provided by the nearest parent provider.
-     *
-     * @throws {Error} When called outside of a provider context
-     * @returns The injected state
-     *
-     * @example
-     * ```vue
-     * <script setup>
-     * const state = useComboboxState() // Throws if no provider found
-     * </script>
-     * ```
-     */
-    useInjectedState: () => Return
-]>;
-/**
- * Creates a pair of composables for strict provide/inject pattern with required context.
- * Unlike Vue's standard inject, this ensures the context is always provided, throwing an error otherwise.
- *
- * This is useful for component libraries where certain child components must be used
- * within a specific parent component context.
- *
- * @template Arguments - The arguments accepted by the composable function
- * @template Return - The return type of the composable function
- *
- * @param composable - The composable function that creates the shared state
- * @param options - Configuration options including context name for error messages
- *
- * @returns A tuple of [useProvidingState, useInjectedState] functions
- *
- * @example
- * ```ts
- * // Define the state structure
- * interface ComboboxState {
- *   items: string[]
- *   selected: Ref<string | null>
- * }
- *
- * // Create the strict injection pair
- * const [useProvideComboboxState, useComboboxState] = createStrictInjection(
- *   (state: ComboboxState) => {
- *     return {
- *       ...state,
- *       select: (item: string) => { state.selected.value = item }
- *     }
- *   },
- *   { name: 'ComboboxState' }
- * )
- *
- * // In parent component (Combobox.vue)
- * const state = useProvideComboboxState({
- *   items: ['Apple', 'Banana', 'Cherry'],
- *   selected: ref(null)
- * })
- *
- * // In child component (ComboboxOption.vue)
- * const { select, selected } = useComboboxState() // ✅ Works inside Combobox
- * // ❌ Throws "[useComboboxState] Missing provider. Make sure to call `useProvideComboboxState` in a parent component."
- * //    if used outside Combobox context
- * ```
- *
- * @see {@link https://vueuse.org/shared/createInjectionState/ VueUse createInjectionState}
- */
-export declare function createStrictInjection<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options: StrictInjectionOptions<Return>): StrictInjectionReturn<Arguments, Return>;
-export {};

package/dist/runtime/helpers/date/create-months.d.ts

@@ -1,3 +0,0 @@
-import type { DateInput } from '@formkit/tempo';
-import type { DateConfig } from '@nui/composals';
-export declare function createMonth(date: DateInput, config: DateConfig, fixedWeeks?: boolean): string[][];

package/dist/runtime/helpers/date/get-days-between.d.ts

@@ -1 +0,0 @@
-export declare function getDaysBetween(start: Date, end: Date): string[];

package/dist/runtime/helpers/date/types.d.ts

@@ -1,19 +0,0 @@
-import type { DateInput } from '@formkit/tempo';
-export type DateMatcher = (date: DateInput) => boolean;
-export interface CalendarGrid<T = string> {
-    /**
-     * A `DateInput` used to represent the month. Since days
-     * from the previous and next months may be included in the
-     * calendar grid, we need a source of truth for the value
-     * the grid is representing.
-     */
-    value: DateInput;
-    /**
-     * An array of arrays representing the weeks in the calendar.
-     * Each sub-array represents a week, and contains the dates for each
-     * day in that week. This structure is useful for rendering the calendar
-     * grid using a table, where each row represents a week and each cell
-     * represents a day.
-     */
-    rows: T[][];
-}

package/dist/runtime/helpers/index.d.ts

@@ -1 +0,0 @@
-export * from './create-strict-injection.js';

package/dist/runtime/helpers/index.js

@@ -1 +0,0 @@
-export * from "./create-strict-injection.js";

package/dist/runtime/utils/color-functions/get-gradient.d.ts

@@ -1,3 +0,0 @@
-import type { NuanceGradient, NuanceTheme } from '@nui/types';
-export declare function getGradient(gradient: NuanceGradient | undefined, theme: NuanceTheme): string;
-export declare function getGradientOutline(gradient: NuanceGradient | undefined, theme: NuanceTheme): string;

package/dist/runtime/utils/color-functions/parse-theme-color.d.ts

@@ -1,14 +0,0 @@
-import type { NuanceColorShade, NuanceTheme } from '@nui/types';
-interface ParseThemeColorResult {
-    color: string;
-    value: string;
-    shade: NuanceColorShade | undefined;
-    variable: `--${string}` | undefined;
-    isThemeColor: boolean;
-}
-export declare function parseThemeColor({ color, theme, }: {
-    color: unknown;
-    theme: NuanceTheme;
-}): ParseThemeColorResult;
-export declare function getThemeColor(color: string | undefined, theme: NuanceTheme): string;
-export {};

package/dist/runtime/utils/converters/rem.d.ts

@@ -1,2 +0,0 @@
-export declare const rem: (value: unknown) => string;
-export declare const em: (value: unknown) => string;

package/dist/runtime/utils/get-mod.d.ts

@@ -1,2 +0,0 @@
-export type Mod = Record<string, any>;
-export declare function getMod(props: Mod | Mod[]): Mod;

package/dist/runtime/utils/get-size.d.ts

@@ -1,6 +0,0 @@
-export declare function getSize(size: unknown, prefix?: string, convertToRem?: boolean): string | undefined;
-export declare const getSpacing: (size: unknown) => string | undefined;
-export declare function getRadius(size: unknown): string | undefined;
-export declare const getFontSize: (size: unknown) => string | undefined;
-export declare const getLineHeight: (size: unknown) => string | undefined;
-export declare function getShadow(size: unknown): string | undefined;