@v1nt1248/3nclient-lib 0.3.9 → 0.3.12

package/dist/components/ui3n-radio-group/types.d.ts

@@ -1,32 +1,110 @@
 import { VNode } from 'vue';
+/**
+ * Radio value type
+ */
 export type Ui3nRadioValue = boolean | string | number;
+/**
+ * Radio component properties
+ */
 export interface Ui3nRadioProps {
+    /**
+     * Current radio value
+     */
     modelValue?: Ui3nRadioValue;
+    /**
+     * Value when radio is checked
+     */
     checkedValue?: Ui3nRadioValue;
+    /**
+     * Value when radio is unchecked
+     */
     uncheckedValue?: Ui3nRadioValue;
+    /**
+     * Radio size
+     */
     size?: number | string;
+    /**
+     * Radio color
+     */
     color?: string;
+    /**
+     * Whether radio is disabled
+     * @default false
+     */
     disabled?: boolean;
 }
+/**
+ * Radio component emits
+ */
 export interface Ui3nRadioEmits {
+    /**
+     * Emitted when radio value changes
+     */
     (ev: 'change', value: Ui3nRadioValue): void;
+    /**
+     * Emitted when model value updates
+     */
     (ev: 'update:modelValue', value: Ui3nRadioValue): void;
 }
+/**
+ * Radio component slots
+ */
 export interface Ui3nRadioSlots {
+    /**
+     * Checked icon slot
+     */
     checkedIcon: () => VNode;
+    /**
+     * Unchecked icon slot
+     */
     uncheckedIcon: () => VNode;
+    /**
+     * Default slot
+     */
     default: () => VNode;
 }
+/**
+ * Radio group component properties
+ */
 export interface Ui3nRadioGroupProps {
+    /**
+     * Radio group name
+     */
     name: string;
+    /**
+     * Current radio group value
+     */
     modelValue: Ui3nRadioValue;
+    /**
+     * Radio group direction
+     * @default 'vertical'
+     */
     direction?: 'horizontal' | 'vertical';
+    /**
+     * Whether radio group is disabled
+     * @default false
+     */
     disabled?: boolean;
 }
+/**
+ * Radio group component emits
+ */
 export interface Ui3nRadioGroupEmits {
+    /**
+     * Emitted when radio group value changes
+     */
     (ev: 'change', value: Ui3nRadioValue): void;
+    /**
+     * Emitted when model value updates
+     */
     (ev: 'update:modelValue', value: Ui3nRadioValue): void;
 }
+/**
+ * Radio group component slots
+ */
 export interface Ui3nRadioGroupSlots {
+    /**
+     * Default slot
+     */
     default: () => VNode;
 }

package/dist/components/ui3n-selector/types.d.ts

@@ -1,43 +1,138 @@
 import { VNode } from 'vue';
 import { PrepareComponentEmits, Nullable } from '../../types';
+/**
+ * Base selector option interface
+ */
 export interface Ui3nSelectorOptionBase {
+    /**
+     * Option ID
+     */
     id: string;
     [key: string]: any;
 }
+/**
+ * Function to display selector item
+ */
 export type Ui3nSelectorItemDisplayingFunction<T extends Ui3nSelectorOptionBase> = (v: T) => string;
+/**
+ * Selector value type
+ */
 export type Ui3nSelectorValue<T extends Ui3nSelectorOptionBase> = T | T[keyof T] | null;
+/**
+ * Selector component properties
+ */
 export interface Ui3nSelectorProps<T extends Ui3nSelectorOptionBase> {
+    /**
+     * Current selector value
+     */
     modelValue: Ui3nSelectorValue<T>;
+    /**
+     * Label text
+     */
     label?: string;
+    /**
+     * Placeholder text
+     */
     placeholder?: string;
+    /**
+     * Items to display
+     */
     items?: T[];
+    /**
+     * Property to use as value
+     */
     itemValue?: keyof T;
+    /**
+     * Property or function to display item
+     */
     itemDisplay?: keyof T | Ui3nSelectorItemDisplayingFunction<T>;
+    /**
+     * Custom filter function
+     */
     customFilter?: (value: Ui3nSelectorValue<T>, query: string) => boolean;
+    /**
+     * Whether to return the whole object or just the value
+     * @default false
+     */
     returnObject?: boolean;
+    /**
+     * Whether to show clear button
+     * @default false
+     */
     clearable?: boolean;
+    /**
+     * Whether to show search input
+     * @default false
+     */
     withSearch?: boolean;
+    /**
+     * Whether to hide selected item
+     * @default false
+     */
     hideSelected?: boolean;
+    /**
+     * Text to show when no data
+     */
     noDataText?: string;
+    /**
+     * Whether selector is disabled
+     * @default false
+     */
     disabled?: boolean;
 }
+/**
+ * Selector component events map
+ */
 export interface Ui3nSelectorEventsMap<T extends Ui3nSelectorOptionBase> {
+    /**
+     * Emitted when model value updates
+     */
     'update:modelValue': Ui3nSelectorValue<T>;
+    /**
+     * Emitted when list is opened
+     */
     'list:open': undefined;
+    /**
+     * Emitted when list is closed
+     */
     'list:close': undefined;
+    /**
+     * Emitted when component is focused
+     */
     focus: undefined;
+    /**
+     * Emitted when component loses focus
+     */
     blur: undefined;
 }
+/**
+ * Selector component events type
+ */
 export type Ui3nSelectorEvents = keyof Ui3nSelectorEventsMap<any>;
+/**
+ * Selector component emits
+ */
 export type Ui3nSelectorEmits<T extends Ui3nSelectorOptionBase> = PrepareComponentEmits<Ui3nSelectorEventsMap<T>>;
+/**
+ * Selector component slots
+ */
 export interface Ui3nSelectorSlots<T extends Ui3nSelectorOptionBase> {
+    /**
+     * No data text slot
+     */
     noDataText?: () => VNode;
+    /**
+     * Item slot
+     */
     item?: (props: {
         item: T;
         index: number;
         activeIndex: Nullable<number>;
         query?: string;
     }) => VNode;
+    /**
+     * Selection slot
+     */
     selection?: (props: {
         value: Ui3nSelectorValue<T>;
         selectedItem: T | undefined;

package/dist/components/ui3n-slider/types.d.ts

@@ -1,20 +1,71 @@
 export interface UI3nSliderProps {
+    /**
+     * Current slider value
+     */
     modelValue: number | [number, number];
+    /**
+     * Slider step
+     */
     step?: string | number;
+    /**
+     * Whether slider is range
+     * @default false
+     */
     range?: boolean;
+    /**
+     * Minimum value
+     */
     min?: string | number;
+    /**
+     * Maximum value
+     */
     max?: string | number;
+    /**
+     * Label visibility
+     * @default 'normal'
+     */
     labelVisible?: 'always' | 'normal' | 'never';
+    /**
+     * Label text color
+     */
     labelTextColor?: string;
+    /**
+     * Label color
+     */
     labelColor?: string;
+    /**
+     * Active color
+     */
     activeColor?: string;
+    /**
+     * Track color
+     */
     trackColor?: string;
+    /**
+     * Track height
+     */
     trackHeight?: string | number;
+    /**
+     * Thumb size
+     */
     thumbSize?: string | number;
+    /**
+     * Thumb color
+     */
     thumbColor?: string;
+    /**
+     * Transform value method
+     */
     transformValueMethod?: (value: number) => string;
+    /**
+     * Whether slider is disabled
+     * @default false
+     */
     disabled?: boolean;
 }
 export interface UI3nSliderEmits {
+    /**
+     * Emitted when model value updates
+     */
     (event: 'update:modelValue', value: number | [number, number]): void;
 }

package/dist/components/ui3n-step-line-bar/types.d.ts

@@ -1,5 +1,17 @@
+/**
+ * Step line bar component properties
+ */
 export interface Ui3nStepLineBarProps {
+    /**
+     * Step label
+     */
     label: string;
+    /**
+     * Current step
+     */
     current: number;
+    /**
+     * Total number of steps
+     */
     steps: number;
 }

package/dist/components/ui3n-switch/types.d.ts

@@ -1,14 +1,45 @@
 import { VNode } from 'vue';
+/**
+ * Switch component properties
+ */
 export interface Ui3nSwitchProps {
+    /**
+     * Current switch value
+     */
     modelValue: boolean;
+    /**
+     * Switch size
+     */
     size?: number | string;
+    /**
+     * Switch color
+     */
     color?: string;
+    /**
+     * Whether switch is disabled
+     * @default false
+     */
     disabled?: boolean;
 }
+/**
+ * Switch component emits
+ */
 export interface Ui3nSwitchEmits {
+    /**
+     * Emitted when switch value changes
+     */
     (ev: 'change', value: boolean): void;
+    /**
+     * Emitted when model value updates
+     */
     (ev: 'update:modelValue', value: boolean): void;
 }
+/**
+ * Switch component slots
+ */
 export interface Ui3nSwitchSlots {
+    /**
+     * Default slot
+     */
     default: () => VNode;
 }

package/dist/components/ui3n-table/types.d.ts

@@ -1,95 +1,293 @@
 import { VNode, Ref, ComputedRef } from 'vue';
+/**
+ * Base table item interface
+ */
 export interface Ui3nTableBodyBaseItem {
+    /**
+     * Item ID
+     */
     id?: string | number | symbol;
 }
+/**
+ * Table sort type
+ */
 export type Ui3nTableSort<T extends Ui3nTableBodyBaseItem> = {
+    /**
+     * Sort field
+     */
     field: keyof T;
+    /**
+     * Sort direction
+     */
     direction: 'asc' | 'desc';
 };
+/**
+ * Table configuration type
+ */
 export type Ui3nTableConfig<T extends Ui3nTableBodyBaseItem, K extends keyof T = keyof T> = {
+    /**
+     * Table name
+     */
     tableName?: string;
+    /**
+     * Sort order
+     */
     sortOrder?: Ui3nTableSort<T>;
+    /**
+     * Selection mode
+     */
     selectable?: 'single' | 'multiple';
+    /**
+     * Column styles
+     */
     columnStyle?: {
         [P in Omit<K, 'id'> as string | number]: Record<string, string>;
     };
+    /**
+     * Field to use as row key
+     */
     fieldAsRowKey?: keyof T;
+    /**
+     * Whether to show no data message
+     * @default true
+     */
     showNoDataMessage?: boolean;
+    /**
+     * Minimum height for unused place
+     */
     minHeightUnusedPlace?: number | string;
 };
+/**
+ * Table header properties type
+ */
 export type Ui3nTableHeadProps<T extends Ui3nTableBodyBaseItem> = {
+    /**
+     * Header key
+     */
     key: keyof T;
+    /**
+     * Header text
+     */
     text: string;
+    /**
+     * Whether header is sortable
+     * @default false
+     */
     sortable?: boolean;
+    /**
+     * Header cell style
+     */
     headCellStyle?: Record<string, string>;
+    /**
+     * Format function
+     */
     format?: (content: unknown) => string;
+    /**
+     * Whether header is hidden
+     * @default false
+     */
     hidden?: boolean;
+    /**
+     * Header index
+     */
     index?: number;
 };
+/**
+ * Table body properties type
+ */
 export type Ui3nTableBodyProps<T extends Ui3nTableBodyBaseItem, K extends keyof T = keyof T> = {
+    /**
+     * Body content
+     */
     content: T[];
+    /**
+     * Row styles
+     */
     rowsStyle?: {
         [P in T[K] as string | number]: Record<string, string>;
     };
 };
+/**
+ * Table component properties
+ */
 export interface Ui3nTableProps<T extends Ui3nTableBodyBaseItem> {
+    /**
+     * Table configuration
+     */
     config: Ui3nTableConfig<T>;
+    /**
+     * Table header
+     */
     head: Ui3nTableHeadProps<T>[];
+    /**
+     * Table body
+     */
     body: Ui3nTableBodyProps<T>;
 }
+/**
+ * Table component events
+ */
 export interface Ui3nTableEmits<T extends Ui3nTableBodyBaseItem> {
+    /**
+     * Emitted when sort changes
+     */
     (ev: 'change:sort', val: Ui3nTableSort<T>): void;
+    /**
+     * Emitted when row is selected
+     */
     (ev: 'select:row', val: T[]): void;
 }
+/**
+ * Table other slots
+ */
 export type Ui3nTableOtherSlots = {
+    /**
+     * No data slot
+     */
     'no-data': () => VNode;
+    /**
+     * Unused place slot
+     */
     'unused-place': () => VNode;
 };
+/**
+ * Table group actions slot
+ */
 export type Ui3nTableGroupActionsSlot<T extends Ui3nTableBodyBaseItem> = {
+    /**
+     * Group actions slot
+     */
     'group-actions': ({ selectedRows }: {
         selectedRows: T[];
     }) => VNode;
 };
+/**
+ * Table header cell slot
+ */
 export type Ui3nTableHeaderCellSlot<T extends Ui3nTableBodyBaseItem, K extends string & keyof T> = {
     [p in `header-cell-${K}`]: () => VNode;
 };
+/**
+ * Table body row slot scope
+ */
 export type Ui3nTableBodyRowSlotScope<T extends Ui3nTableBodyBaseItem, K extends keyof T = keyof T> = {
+    /**
+     * Row data
+     */
     row: T;
+    /**
+     * Row style
+     */
     rowStyle?: Record<string, string>;
+    /**
+     * Row index
+     */
     rowIndex: number;
+    /**
+     * Whether row is selected
+     */
     isRowSelected?: boolean;
+    /**
+     * Column styles
+     */
     columnStyle?: {
         [P in Omit<K, 'id'> as string | number]: Record<string, string>;
     };
+    /**
+     * Events
+     */
     events?: {
+        /**
+         * Select function
+         */
         select: (row: T, withoutEvents?: boolean) => void;
     };
 };
+/**
+ * Table body row slot
+ */
 export type Ui3nTableBodyRowSlot<T extends Ui3nTableBodyBaseItem> = {
+    /**
+     * Row slot
+     */
     row: (scope: Ui3nTableBodyRowSlotScope<T>) => VNode;
 };
+/**
+ * Table body row cell slot scope
+ */
 export type Ui3nTableBodyRowCellSlotScope<T extends Ui3nTableBodyBaseItem, K extends string & keyof T> = {
+    /**
+     * Row data
+     */
     row: T;
+    /**
+     * Row index
+     */
     rowIndex: number;
+    /**
+     * Whether row is selected
+     */
     isRowSelected?: boolean;
+    /**
+     * Column styles
+     */
     columnStyle?: {
         [P in Omit<K, 'id'> as string | number]: Record<string, string>;
     };
+    /**
+     * Cell data
+     */
     cell: T[K];
 };
+/**
+ * Table body row cell slot
+ */
 export type Ui3nTableBodyRowCellSlot<T extends Ui3nTableBodyBaseItem, K extends string & keyof T> = {
     [p in `row-cell-${K}`]: (scope: Ui3nTableBodyRowCellSlotScope<T, K>) => VNode;
 };
+/**
+ * Table slots
+ */
 export type Ui3nTableSlots<T extends Ui3nTableBodyBaseItem, K extends string & keyof T> = Ui3nTableOtherSlots & Ui3nTableGroupActionsSlot<T> & Ui3nTableHeaderCellSlot<T, K> & Ui3nTableBodyRowSlot<T> & Ui3nTableBodyRowCellSlot<T, K>;
+/**
+ * Table sort icon properties
+ */
 export interface Ui3nTableSortIconProps {
+    /**
+     * Icon size
+     */
     size?: string | number;
+    /**
+     * Icon color
+     */
     color?: string;
+    /**
+     * Icon value
+     */
     value: 'asc' | 'desc';
 }
+/**
+ * Table expose
+ */
 export type Ui3nTableExpose<T extends Ui3nTableBodyBaseItem> = {
+    /**
+     * Selected rows
+     */
     selectedRows: Ref<Set<T> | Array<T[keyof T]>>;
+    /**
+     * Selected rows array
+     */
     selectedRowsArray: ComputedRef<T[]>;
+    /**
+     * Whether has group actions row
+     */
     hasGroupActionsRow: Ref<boolean>;
+    /**
+     * Get row style
+     */
     getRowStyle: (row: T) => Record<string, string>;
+    /**
+     * Close group actions row
+     */
     closeGroupActionsRow: () => void;
 };