@v1nt1248/3nclient-lib 0.3.9 → 0.3.11

package/src/components/ui3n-selector/types.ts

@@ -1,40 +1,120 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type { VNode } from 'vue';
-import type { PrepareComponentEmits, Nullable } from '../../types';
+import type { 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>;
 
 // export interface Ui3nSelectorEmits<T extends Ui3nSelectorOptionBase> {
@@ -45,10 +125,25 @@ export type Ui3nSelectorEvents = keyof Ui3nSelectorEventsMap<any>;
 //   (event: 'blur'): void;
 // }
 
+/**
+ * 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 }) => VNode;
 }

package/src/components/ui3n-slider/types.ts

@@ -1,21 +1,72 @@
 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/src/components/ui3n-step-line-bar/types.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/src/components/ui3n-switch/types.ts

@@ -1,17 +1,48 @@
 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/src/components/ui3n-table/types.ts

@@ -1,108 +1,312 @@
 import { VNode, type Ref, type 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';
   // draggableRows?: boolean; // ToDo this will be done in the next version
   // draggableColumns?: boolean; // ToDo this will be done in the next version
+  /**
+   * 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> = {
+  /**
+   * Header cell slot
+   */
   [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> = {
+  /**
+   * Row cell slot
+   */
   [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;
 };

package/src/components/ui3n-tabs/types.ts

@@ -1,19 +1,57 @@
 import { VNode } from 'vue';
 
+/**
+ * Tabs component properties
+ */
 export interface Ui3nTabsProps {
+  /**
+   * Current active tab index
+   */
   modelValue: number;
+  /**
+   * Direction of tabs
+   * @default 'horizontal'
+   */
   itemDirection?: 'horizontal' | 'vertical';
+  /**
+   * Active tab color
+   */
   activeColor?: string;
+  /**
+   * Inactive tab color
+   */
   inactiveColor?: string;
+  /**
+   * Indicator color
+   */
   indicatorColor?: string;
+  /**
+   * Indicator size
+   */
   indicatorSize?: number | string;
+  /**
+   * Indicator position
+   * @default 'normal'
+   */
   indicatorPosition?: 'normal' | 'reverse';
 }
 
+/**
+ * Tabs component emits
+ */
 export interface Ui3nTabsEmits {
+  /**
+   * Emitted when model value updates
+   */
   (ev: 'update:modelValue', val: number): void;
 }
 
+/**
+ * Tabs component slots
+ */
 export interface Ui3nTabsSlots {
+  /**
+   * Default slot
+   */
   default: () => VNode;
 }