@voicenter-team/voicenter-ui-plus 2.0.12 → 3.0.0

package/library/types/types/VcTour.types.d.ts

@@ -0,0 +1,52 @@
+import type { Component, CSSProperties, VNode } from 'vue';
+import { ButtonProps } from 'element-plus';
+import type { IScrollIntoViewOptions, PopoverPlacementType } from '.';
+export type ITargetFn = () => HTMLElement;
+export interface IMaskTourConfig {
+    style?: CSSProperties;
+    color?: string;
+}
+export interface ITourGap {
+    offset: number;
+    radius: number;
+}
+export interface IVTStep {
+    step: string;
+    target: string | HTMLElement | ITargetFn;
+    title: string;
+    description?: string;
+    props?: IVTStepProps;
+}
+export type INextButtonProps = {
+    children: VNode | string;
+    onClick: () => void;
+} & Partial<ButtonProps>;
+export interface IVTStepProps {
+    showArrow?: boolean;
+    placement?: PopoverPlacementType;
+    contentStyle?: CSSProperties;
+    mask?: boolean | IMaskTourConfig;
+    type?: 'default' | 'primary';
+    nextButtonProps?: INextButtonProps;
+    prevButtonProps?: INextButtonProps;
+    scrollIntoViewOptions?: boolean | IScrollIntoViewOptions;
+    showClose?: boolean;
+    closeIcon?: string | Component;
+}
+export interface IVTProps {
+    appendTo?: string | HTMLElement;
+    modelValue?: boolean;
+    current?: number;
+    showArrow?: boolean;
+    placement?: PopoverPlacementType;
+    contentStyle?: CSSProperties;
+    mask?: boolean | IMaskTourConfig;
+    gap?: ITourGap;
+    scrollIntoViewOptions?: boolean | IScrollIntoViewOptions;
+    zIndex?: number;
+    showClose?: boolean;
+    closeIcon?: string | Component;
+    closeOnPressEscape?: boolean;
+    targetAreaClickable?: boolean;
+    steps?: Array<IVTStep>;
+}

package/library/types/types/VcTree.types.d.ts

@@ -0,0 +1,33 @@
+import type { ConfigOptionType, OptionObjectValueType } from './OptionAndConfig.types';
+import type { TIcon } from './icons.types';
+export declare type VcTreeNodeType<T extends string = string> = {
+    id?: string | number;
+    key?: string | number;
+    label?: string;
+    /**
+     * Icon shown next to the node label. Accepts a class string
+     * (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide icon
+     * from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    children?: Array<VcTreeNodeType>;
+    parent?: VcTreeNodeType;
+    checked?: boolean;
+    _keyPath?: string;
+    type?: T;
+} & OptionObjectValueType;
+export declare type VcTreeConfig<NodeType extends VcTreeNodeType> = ConfigOptionType<NodeType> & {
+    childrenKey: keyof NodeType;
+    valueKey: keyof NodeType;
+    labelKey: keyof NodeType;
+    filterBy?: string;
+    iconKey?: keyof NodeType;
+    disabledKey?: keyof NodeType;
+    filterLocale?: string;
+    nodeClassName?: string;
+    nodeLabelClassName?: string;
+};
+export type VcTreeFilterParams = {
+    searchFields: Array<string>;
+    filterText: string;
+};

package/library/types/types/VcWizard.types.d.ts

@@ -0,0 +1,29 @@
+import { TIcon } from './icons.types';
+export declare type VcWizardStepType = {
+    step: string;
+    label: string;
+    /**
+     * Icon shown in the step circle. Accepts a class string (legacy
+     * `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    icon?: TIcon;
+    class?: string;
+    attrs?: {
+        [key: string]: string | number;
+    };
+    validateStepFn?: () => boolean | Promise<boolean>;
+    prepareStepFn?: () => void | Promise<void>;
+    initStepFn?: () => void | Promise<void>;
+    /** @deprecated v3: renamed to `validateStepFn`. Removed in v4. */
+    beforeStepFn?: () => boolean | Promise<boolean>;
+    /** @deprecated v3: renamed to `initStepFn`. Removed in v4. */
+    onEnterStepFn?: () => void | Promise<void>;
+};
+export type VcWizardSummaryContentType = {
+    label: string;
+    value: unknown;
+};
+export declare type VcWizardSummaryType = {
+    [key: string | number]: Array<VcWizardSummaryContentType>;
+};

package/library/types/types/basic.types.d.ts

@@ -0,0 +1,17 @@
+export type UnwrapArray<T> = T extends Array<infer R> ? R : never;
+export type TSelectSlots<Selected, Option> = {
+    'prefix-icon'(props: {
+        selected: Selected;
+    }): void;
+    'default'(): void;
+    'load-more-option'(): void;
+    'option'(props: {
+        option: Option;
+    }): void;
+};
+export type IScrollBehavior = 'auto' | 'smooth';
+export interface IScrollIntoViewOptions {
+    behavior?: IScrollBehavior;
+    block?: 'start' | 'center' | 'end' | 'nearest';
+    inline?: 'start' | 'center' | 'end' | 'nearest';
+}

package/library/types/types/icons.types.d.ts

@@ -0,0 +1,23 @@
+import type { Component } from 'vue';
+import { VcIconList } from '../enum/icons';
+export type TypeOfVcList = typeof VcIconList;
+export type TVcIconListName = TypeOfVcList[number]['class'];
+export type TIconClassList = TVcIconListName;
+export type TIconClass = `${TIconClassList} ${string}` | TIconClassList | string;
+/**
+ * Unified icon prop type accepted across the library.
+ *
+ * Accepts either:
+ *  - a legacy class string (e.g. `'vc-icon-search'`),
+ *  - a Lucide icon name as a string (e.g. `'bell-plus'`, `'BellPlus'`,
+ *    `'apple'`) — resolved dynamically at runtime, or
+ *  - a Vue `Component` (e.g. a Lucide icon from `@lucide/vue`:
+ *    `import { Search } from '@lucide/vue'`).
+ *
+ * Components consuming this should render via `VcIcon`, which picks
+ * the correct strategy based on the runtime value's type.
+ */
+export type TIcon = TIconClass | Component;
+export declare function isIconComponent(icon: TIcon | undefined): icon is Component;
+export declare function isIconString(icon: TIcon | undefined): icon is string;
+export declare function isVueComponent(value: unknown): value is Component;

package/library/types/types/index.d.ts

@@ -0,0 +1,52 @@
+export * from './AppendToTarget.types';
+export * from './basic.types';
+export * from './Dropdown.types';
+export * from './Entry.types';
+export * from './ExcelParser.types';
+export * from './generic.types';
+export * from './OptionAndConfig.types';
+export * from './VcDropdown.types';
+export * from './VcButton.types';
+export * from './VcCollapse.types';
+export * from './VcDatePicker.types';
+export * from './VcDatetimeRangePicker.types';
+export * from './VcDelimitedList.types';
+export * from './VcExtendedDatetimeRangePicker.types';
+export * from './VcFileUploader.types';
+export * from './VcForm.types';
+export * from './VcHyperLink.types';
+export * from './VcIconPicker.types';
+export * from './VcInput.types';
+export * from './VcOtpInput.types';
+export * from './VcLoading.types';
+export * from './VcMeterGroup.types';
+export * from './VcModal.types';
+export * from './VcNotification.types';
+export * from './VcPagination.types';
+export * from './VcPopover.types';
+export * from './VcProgress.types';
+export * from './VcRadioTabs.types';
+export * from './VcSelect.types';
+export * from './VcSkeletonLoader.types';
+export * from './VcSplitButton.types';
+export * from './VcSwitch.types';
+export * from './VcTable.types';
+export * from './VcTabs.types';
+export * from './VcTag.types';
+export * from './VcTagInput.types';
+export * from './VcRTL.types';
+export * from './VcWizard.types';
+export * from './VueGeneric.types';
+export * from './icons.types';
+export * from './VcSparkline.types';
+export * from './VcTree.types';
+export * from './VcMdEditor.types';
+export * from './VcSystemUserPrompt.types';
+export * from './VcSoundPlayer.types';
+export * from './VcSoundPlayerInstance.types';
+export * from './Entity.basic.types';
+export * from './Entity.types';
+export * from './Tabs';
+export * from './VcEditableTabs.types';
+export * from './VcSipFlow.types';
+export * from './VcTour.types';

package/library/types/utils/ToastEventBus.d.ts

@@ -0,0 +1,15 @@
+type ToastEventHandler<T = unknown> = {
+    bivarianceHack(evt?: T): void;
+}['bivarianceHack'];
+type EventBus = {
+    on<T = unknown>(type: string, fn: ToastEventHandler<T>): void;
+    emit<T = unknown>(type: string, evt?: T): void;
+    off<T = unknown>(type: string, fn: ToastEventHandler<T>): void;
+};
+declare global {
+    interface VcGlobalSingletons {
+        ToastEventBus: EventBus;
+    }
+}
+declare const _default: EventBus;
+export default _default;

package/library/types/utils/UniqueComponentId.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface VcGlobalSingletons {
+        UniqueComponentId: {
+            lastId: number;
+        };
+    }
+}
+export default function (prefix?: string): string;

package/library/types/utils/excelParser/configs.d.ts

@@ -0,0 +1,5 @@
+import type { OptionsType } from '../../types';
+export declare const defaultOptions: OptionsType;
+declare const sheetJSFT: string;
+declare const ignoredAsciiCodeSymbols: Array<number>;
+export { sheetJSFT, ignoredAsciiCodeSymbols };

package/library/types/utils/excelParser/helper.d.ts

@@ -0,0 +1,28 @@
+import type { BindingErrorsType, ErrorRowType, ParsedRow, ResultValidData } from '../../types';
+import type { WorkSheet } from 'xlsx';
+/**
+ * Raw cell value as emitted by xlsx `sheet_to_json` with `header: 1`. Cells
+ * can be primitives, dates, or `null` for empty intermediate cells.
+ */
+export type RawCellValue = string | number | boolean | Date | null | undefined;
+/**
+ * Array-of-arrays row produced by xlsx `sheet_to_json({ header: 1 })`.
+ */
+export type SheetAoaRow = Array<RawCellValue>;
+export declare const readXLSXFile: (bStr: string | ArrayBuffer | null | undefined) => Promise<import("xlsx").WorkBook>;
+export declare const convertSheetToJson: (sheetData: WorkSheet) => Promise<Array<SheetAoaRow>>;
+export declare const normalizeData: <T>(data: T) => T;
+export declare const makeCols: (refStr: string) => Promise<{
+    name: string;
+    key: number;
+    x: number;
+}[]>;
+export declare const iError: (column: string, errors: ResultValidData) => {
+    column: string;
+    errors: ResultValidData;
+};
+export declare const mapRows: (sheet: Array<SheetAoaRow>, head: Array<string>, cols: Array<{
+    name: string;
+    key: number;
+}>) => Array<ParsedRow>;
+export declare const bindErrors: (index: number, errors: Array<ErrorRowType>) => BindingErrorsType;

package/library/types/utils/excelParser/parser.d.ts

@@ -0,0 +1,146 @@
+import type { BindingErrorsType, BindingHeaderObjectType, BindingRowItemType, ErrorRowType, FileObjectType, ParserDataObjectType, ValidateRowReturnType } from '../../types';
+/**
+ * Excel Parser Instance
+ *
+ * Desc: Read, Parse and Validation Excel file
+ *
+ * the value of the parameter 'hasHeader/isHeader'
+ * is specified depending on whether the file has a header
+ */
+declare class Parser {
+    /**
+     * Represents whether a given block of code or element is a header.
+     */
+    private isHeader;
+    /**
+     * Represents a file object.
+     */
+    private file;
+    /**
+     * Represents an array of ParserDataObjectType.
+     */
+    private data;
+    /**
+     * Represents the original data in the form of an array of ParserDataObjectType.
+     */
+    private originalData;
+    /**
+     * Represents the data for binding rows.
+     */
+    private bindData;
+    /**
+     * Represents an array of binding errors.
+     */
+    private errors;
+    /**
+     * Constructor
+     *
+     * @param hasHeader
+     */
+    constructor(hasHeader?: boolean);
+    /**
+     * Checks if the object has a header.
+     */
+    get hasHeader(): boolean;
+    /**
+     * Set whether the header is enabled or disabled.
+     */
+    set hasHeader(val: boolean);
+    /**
+     * Checks if the object has an original file.
+     */
+    get hasOriginalFile(): FileObjectType;
+    /**
+     * Retrieves the accepted file types for uploading in the application.
+     */
+    getFileAccept(): string;
+    /**
+     * Sets the header value.
+     */
+    setHeader(val: boolean): void;
+    /**
+     * Retrieves the data in a normalized format.
+     */
+    getData(): Array<ParserDataObjectType>;
+    /**
+     * Sets the data for the object.
+     */
+    setData(data: Array<ParserDataObjectType>): void;
+    /**
+     * Retrieves the original data from the parser.
+     */
+    getOriginalData(): Array<ParserDataObjectType>;
+    /**
+     * Sets the original data for the parser.
+     */
+    setOriginalData(data: Array<ParserDataObjectType>): void;
+    /**
+     * Retrieves the binding data.
+     */
+    getBindData(): Array<BindingRowItemType>;
+    /**
+     * Sets the bind data for the method.
+     */
+    setBindData(data: Array<BindingRowItemType>): void;
+    /**
+     * Sets the errors for the current instance.
+     */
+    setError(errors: Array<BindingErrorsType>): void;
+    /**
+     * Retrieves the errors associated with the current instance.
+     */
+    getErrors(): Array<BindingErrorsType>;
+    /**
+     * Checks if there are any errors present in the object.
+     */
+    hasErrors(): boolean;
+    /**
+     * Check if the given index is a valid index within the bindData array.
+     */
+    _isValidIndex(index: number): boolean;
+    /**
+     * Deletes the error at the specified index.
+     */
+    _deleteError(index: number): void;
+    /**
+     * Reads the content of a file and returns parsed data.
+     */
+    readFile(file: File): Promise<{
+        data: Array<ParserDataObjectType>;
+    }>;
+    /**
+     * Parsed the data in the specified sheet based on the provided row header index.
+     */
+    reparseHeadRowData(sheetIndex: number, rowHeader: number): Promise<{
+        data: Array<ParserDataObjectType>;
+    }>;
+    /**
+     * Binds columns from sheet data to header data.
+     */
+    bindColumns(index: number, headerData: Array<BindingHeaderObjectType>): Promise<{
+        result: Array<BindingRowItemType>;
+        errors: Array<BindingErrorsType>;
+    }>;
+    /**
+     * Validates the binding data using the given header options.
+     */
+    validateBindData(headerOptions: Array<BindingHeaderObjectType>): Array<BindingErrorsType>;
+    /**
+     * Updates the error row in the "errors" array based on the given parameters.
+     */
+    updateErrorRow(row: number, errorRows: Array<ErrorRowType>, valid: boolean): void;
+    /**
+     * Validates a row of data based on the provided header options.
+     */
+    validateRow(index: number, headerOptions: Array<BindingHeaderObjectType>): ValidateRowReturnType;
+    /**
+     * Updates a row in the binding data at the specified index.
+     */
+    updateRow(rowIndex: number, row: BindingRowItemType, headerOptions: Array<BindingHeaderObjectType>): BindingRowItemType;
+    /**
+     * Deletes a row from the bindData array at the specified index.
+     */
+    deleteRow(rowIndex: number): void;
+    resetData(): void;
+}
+export default Parser;

package/library/types/utils/excelParser/validations.d.ts

@@ -0,0 +1,19 @@
+import type { ResultValidData, RuleResultType, RulesObjectType, ValidationFunctionType, ValidationOptionsType } from '../../types';
+/**
+ * Function validate
+ */
+declare const validate: (rule: ValidationFunctionType, value: unknown, opt?: number | boolean) => RuleResultType;
+/**
+ * Function validate Column from options
+ *
+ * @param options - object from header validationOptions
+ *  --Example: validationOptions: { required: true }
+ * @param val - value of variable | column
+ * @returns result: {{valid: boolean, errors: []}}
+ */
+declare const validateColumn: (options: ValidationOptionsType, val: unknown) => ResultValidData;
+/**
+ * Collection of validate functions
+ */
+declare const rules: RulesObjectType;
+export { rules, validate, validateColumn };

package/library/types/utils/globalSingleton.d.ts

@@ -0,0 +1,9 @@
+export declare function globalSymbol(name: string): symbol;
+type GlobalSingletonsBase = Record<never, never>;
+declare global {
+    interface VcGlobalSingletons extends GlobalSingletonsBase {
+    }
+    var __voicenterUiPlusSingletons: Partial<VcGlobalSingletons> | undefined;
+}
+export declare function globalSingleton<K extends keyof VcGlobalSingletons>(key: K, init: () => VcGlobalSingletons[K]): VcGlobalSingletons[K];
+export {};

package/library/types/utils/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+export declare const getRefElement: (ref: HTMLElement | Element | {
+    '$el': HTMLElement;
+}) => HTMLElement | Element | null;
+export declare function resolveFieldData<T = Record<string, unknown>>(obj: T | null | undefined, field: string | ((row: T) => unknown) | null | undefined, defaultValue?: unknown): unknown;
+export declare const getFileSize: (bytes: number, decimals?: number) => (number | string)[] | string;

package/library/types/utils/jsonSchema/helpers.d.ts

@@ -0,0 +1,24 @@
+export default helpers;
+export namespace helpers {
+    export let stringFormats: string[];
+    export { isFormat };
+    export let typeNames: string[];
+    export function getType(val: any): string | undefined;
+    /**
+     * Tries to find the least common schema from two supplied JSON schemas. If it is unable to find
+     * such a schema, it returns null. Incompatibility in structure/types leads to returning null,
+     * except when the difference is only integer/number. Than the 'number' is used instead 'int'.
+     * Types/Structure incompatibility in array items only leads to schema that doesn't specify
+     * items structure/type.
+     * @param {object} schema1 - JSON schema
+     * @param {object} schema2 - JSON schema
+     * @returns {object|null}
+     */
+    export function mergeSchemaObjs(schema1: object, schema2: object): object | null;
+}
+import { isEqual } from 'lodash-es';
+import { xor } from 'lodash-es';
+import { keys } from 'lodash-es';
+import { merge } from 'lodash-es';
+import { isFormat } from './jsonSchemaHelpers';
+export { isEqual, xor, keys, merge };

package/library/types/utils/jsonSchema/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @template {import('json-schema').JSONSchema7} S
+ * @param {unknown} value
+ * @param {object} [options]
+ * @returns {S}
+ */
+export function toJsonSchema<S extends import("json-schema").JSONSchema7>(value: unknown, options?: object | undefined): S;
+export default ToJsonSchema;
+declare class ToJsonSchema {
+    constructor(options: any);
+    options: any;
+    getObjectSchemaDefault(obj: any): {
+        type: string;
+    };
+    getStringSchemaDefault(value: any): {
+        type: string;
+    };
+    objectPostProcessDefault(schema: any, obj: any): any;
+    commmonPostProcessDefault(type: any, schema: any): any;
+    /**
+     * Tries to find the least common schema that would validate all items in the array. More details
+     * helpers.mergeSchemaObjs description
+     * @param {array} arr
+     * @returns {object|null}
+     */
+    getCommonArrayItemSchema(arr: array): object | null;
+    getObjectSchema(obj: any): any;
+    getArraySchemaMerging(arr: any): {
+        type: string;
+    };
+    getArraySchemaNoMerging(arr: any): {
+        type: string;
+    };
+    getArraySchemaTuple(arr: any): {
+        type: string;
+    };
+    getArraySchemaUniform(arr: any): {
+        type: string;
+    };
+    getArraySchema(arr: any): {
+        type: string;
+    };
+    getStringSchema(value: any): any;
+    /**
+     * Gets JSON schema for provided value
+     * @param value
+     * @returns {object}
+     */
+    getSchema(value: any): object;
+}

package/library/types/utils/lucideIcon.d.ts

@@ -0,0 +1,25 @@
+import type { Component } from 'vue';
+/**
+ * Legacy font-icon class strings always start with `vc-`
+ * (e.g. `vc-icon-search`).
+ */
+export declare function isLegacyIconClass(icon: string): boolean;
+/**
+ * Converts Lucide icon identifiers to kebab-case file names.
+ * Accepts `bell-plus`, `BellPlus`, `apple`, `Apple`, etc.
+ */
+export declare function toLucideKebabName(name: string): string;
+/**
+ * Converts Lucide icon identifiers to PascalCase component export names.
+ */
+export declare function toLucidePascalName(name: string): string;
+/**
+ * Returns a previously resolved Lucide icon from the in-memory cache.
+ */
+export declare function getCachedLucideIcon(name: string): Component | null;
+/**
+ * Dynamically imports a Lucide Vue icon by name. Each icon is loaded from
+ * its own ESM module when the host bundler supports subpath imports; otherwise
+ * falls back to the main package export. Resolved icons are cached globally.
+ */
+export declare function resolveLucideIcon(name: string): Promise<Component | null>;

package/library/types/utils/mime-types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gets the mime type from the given buffer.
+ */
+export declare function getMimeTypeFromBuffer(file: ArrayBuffer, fallback?: string): string | undefined;
+/**
+ * Gets the mime type from the given blob.
+ */
+export declare function getMimeTypeFromBlob(blob: Blob): string;
+/**
+ * Gets a file extension from the given mime type
+ */
+export declare function getExtensionFromMimeType(type: string): string | never;

package/library/utils/DomHandler.mjs

@@ -0,0 +1,44 @@
+const createStyleElementFn = (content) => {
+  const styleEl = document.createElement("style");
+  document.head.appendChild(styleEl);
+  styleEl.innerHTML = content;
+  return styleEl;
+};
+const DomHandler = {
+  addClass(element, className) {
+    if (!element) {
+      return;
+    }
+    if (element.classList) {
+      element.classList.add(className);
+    } else {
+      element.className += " " + className;
+    }
+  },
+  removeClass(element, className) {
+    if (element.classList) {
+      element.classList.remove(className);
+    } else {
+      element.className = element.className.replace(new RegExp("(^|\\b)" + className.split(" ").join("|") + "(\\b|$)", "gi"), " ");
+    }
+  },
+  hasClass(element, className) {
+    if (element.classList) {
+      return element.classList.contains(className);
+    }
+    return false;
+  },
+  getWidth(element) {
+    if (element) {
+      let width = element.offsetWidth;
+      const style = getComputedStyle(element);
+      width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+      return width;
+    }
+    return 0;
+  }
+};
+export {
+  createStyleElementFn,
+  DomHandler as default
+};

package/library/utils/ToastEventBus.mjs

@@ -0,0 +1,36 @@
+import { globalSingleton } from "./globalSingleton.mjs";
+function ToastEventBus() {
+  const allHandlers = /* @__PURE__ */ new Map();
+  return {
+    on(type, handler) {
+      const stored = handler;
+      let handlers = allHandlers.get(type);
+      if (!handlers) {
+        handlers = [stored];
+      } else {
+        handlers.push(stored);
+      }
+      allHandlers.set(type, handlers);
+    },
+    off(type, handler) {
+      const stored = handler;
+      const handlers = allHandlers.get(type);
+      if (handlers) {
+        const index = handlers.indexOf(stored);
+        if (index >= 0) {
+          handlers.splice(index, 1);
+        }
+      }
+    },
+    emit(type, evt) {
+      const handlers = allHandlers.get(type);
+      if (handlers) {
+        handlers.slice().forEach((handler) => handler(evt));
+      }
+    }
+  };
+}
+const ToastEventBus$1 = globalSingleton("ToastEventBus", ToastEventBus);
+export {
+  ToastEventBus$1 as default
+};

package/library/utils/UniqueComponentId.mjs

@@ -0,0 +1,9 @@
+import { globalSingleton } from "./globalSingleton.mjs";
+const counter = globalSingleton("UniqueComponentId", () => ({ lastId: 0 }));
+function uniqueComponentId(prefix = "vc_id_") {
+  counter.lastId++;
+  return `${prefix}${counter.lastId}`;
+}
+export {
+  uniqueComponentId as default
+};