@skyworx/dynamic-ui 1.0.7 → 1.0.9

package/dist/types/composables/dynamic-form/useDynamicForm.d.ts

@@ -0,0 +1,228 @@
+import "vue3-toastify/dist/index.css";
+import { DynamicFormProps, FieldMap } from "./types/form.types";
+import { getSectionKey } from "./utils/form.utils";
+export declare function useDynamicForm(props: DynamicFormProps, emit: any): {
+    resolveKeyParams: (keyParams: any[], contextPath?: string, currentField?: any, localData?: any) => Record<string, any>;
+    navigation: {
+        navigationState: import("vue").Ref<{
+            currentContext: string | null;
+            history: {
+                sectionKey: string;
+                hiddenStates: Record<string, boolean>;
+                timestamp: number;
+                sourceAction?: string | undefined;
+                context?: any;
+                backButtonConfig?: {
+                    labelEN?: string | undefined;
+                    labelID?: string | undefined;
+                    labelKR?: string | undefined;
+                    icon?: string | undefined;
+                    variant?: string | undefined;
+                    position?: "left" | "right" | undefined;
+                } | undefined;
+            }[];
+            hiddenStates: Record<string, boolean>;
+            navigationEnabled: Set<string> & Omit<Set<string>, keyof Set<any>>;
+            maxHistoryDepth: number;
+            parentRowContext?: {
+                parentArrayKey: string;
+                rowIndex: number;
+                childArrayKey: string;
+            } | null | undefined;
+        }, import("./navigation/navigation.types").NavigationState | {
+            currentContext: string | null;
+            history: {
+                sectionKey: string;
+                hiddenStates: Record<string, boolean>;
+                timestamp: number;
+                sourceAction?: string | undefined;
+                context?: any;
+                backButtonConfig?: {
+                    labelEN?: string | undefined;
+                    labelID?: string | undefined;
+                    labelKR?: string | undefined;
+                    icon?: string | undefined;
+                    variant?: string | undefined;
+                    position?: "left" | "right" | undefined;
+                } | undefined;
+            }[];
+            hiddenStates: Record<string, boolean>;
+            navigationEnabled: Set<string> & Omit<Set<string>, keyof Set<any>>;
+            maxHistoryDepth: number;
+            parentRowContext?: {
+                parentArrayKey: string;
+                rowIndex: number;
+                childArrayKey: string;
+            } | null | undefined;
+        }>;
+        hasHistory: import("vue").ComputedRef<boolean>;
+        currentContext: import("vue").ComputedRef<string | null>;
+        history: import("vue").ComputedRef<{
+            sectionKey: string;
+            hiddenStates: Record<string, boolean>;
+            timestamp: number;
+            sourceAction?: string | undefined;
+            context?: any;
+            backButtonConfig?: {
+                labelEN?: string | undefined;
+                labelID?: string | undefined;
+                labelKR?: string | undefined;
+                icon?: string | undefined;
+                variant?: string | undefined;
+                position?: "left" | "right" | undefined;
+            } | undefined;
+        }[]>;
+        hiddenStates: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        parentRowContext: import("vue").ComputedRef<{
+            parentArrayKey: string;
+            rowIndex: number;
+            childArrayKey: string;
+        } | null | undefined>;
+        navigateTo: (config: import("./navigation/navigation.types").NavigationConfig, context?: any) => void;
+        navigateBack: () => void;
+        applyHiddenRules: (rules: Record<string, boolean | any>, context?: any) => void;
+        getCurrentBackButton: () => import("./navigation/navigation.types").BackButtonConfig | null;
+        isSectionHidden: (sectionKey: string) => boolean;
+        setSectionHidden: (sectionKey: string, hidden: boolean) => void;
+        clearHistory: () => void;
+        reset: () => void;
+        registerNavigationSection: (sectionKey: string) => void;
+    };
+    tableDialogOpen: import("vue").Ref<boolean, boolean>;
+    tableDialogTitle: import("vue").Ref<string, string>;
+    tableDialogIcon: import("vue").Ref<string, string>;
+    tableDialogFields: import("vue").Ref<any[], any[]>;
+    tableRowFormData: any;
+    tableRowErrors: Record<string, string>;
+    activeTableKey: import("vue").Ref<string, string>;
+    editingRowIndex: import("vue").Ref<number | null, number | null>;
+    tableDialogViewOnly: import("vue").Ref<boolean, boolean>;
+    confirmDeletePending: import("vue").Ref<{
+        propsTable: any;
+        row: any;
+    } | null, {
+        propsTable: any;
+        row: any;
+    } | {
+        propsTable: any;
+        row: any;
+    } | null>;
+    confirmDeleteOpen: import("vue").Ref<boolean, boolean>;
+    tableDialogSize: import("vue").Ref<string, string>;
+    isTemporaryTable: (pt: any) => boolean;
+    isActionViewOnly: (action: any) => any;
+    tableRows: (pt: any) => any[];
+    resolveTableFields: (pt: any) => any[];
+    confirmTableDelete: (pt: any, row: any) => void;
+    executeTableDelete: () => void;
+    handleTableRowUpdate: (model: string, value: any) => void;
+    openTableRowDialog: (pt: any, tAction: any, rowData?: any) => void;
+    handleDataTableAction: (pt: any, payload: {
+        action: string;
+        row: any;
+        selection?: any[];
+        isLocalSave?: boolean;
+        modelDatatable?: string;
+        actionType?: string;
+        originalRow?: any;
+        rowIndex?: number | null;
+    }) => void;
+    saveTableRow: () => void;
+    isActionVisible: (action: any) => boolean | undefined;
+    handleGlobalButtonClick: (action: any) => void;
+    confirmAction: () => void;
+    performAction: (action: any) => Promise<void>;
+    handleSubmit: () => Promise<void>;
+    handleCancel: () => any;
+    handleFieldUpdate: (model: string, value: any, sectionKey?: string) => void;
+    getCleanPayload: () => Record<string, any>;
+    applyFieldMapping: (data: Record<string, any>, mapping: Record<string, any>) => Record<string, any>;
+    handleResponseMapping: (res: any, mapping: Record<string, any>, basePath?: string) => void;
+    handleClearMapping: (mapping: Record<string, any>, basePath?: string) => void;
+    getFormArrayModels: () => import("./types/form.types").FormArrayModel[];
+    normalizedData: import("vue").ComputedRef<Record<string, any>>;
+    getNormalizedData: (data: Record<string, any>, contextPath?: string, debugTag?: string) => Record<string, any>;
+    evaluateLogic: (rule: any, customData?: Record<string, any>, debugTag?: string, contextPath?: string) => any;
+    resolveActiveRule: (rules: any, data: Record<string, any>, debugTag: any, contextPath?: string) => any;
+    resolveValueIdentifier: (modelName: string, value: any, fieldOverride?: any, contextObj?: any) => any;
+    getFilteredItems: (field: any, customData?: Record<string, any>, contextPath?: string) => any[];
+    isFieldVisible: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldRequired: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldDisabled: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldReadonly: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isFieldHidden: (field: any, customData?: Record<string, any>, contextPath?: string) => boolean;
+    isSectionVisible: (section: any, customData?: Record<string, any>) => boolean;
+    isSectionHidden: (section: any, customData?: Record<string, any>) => boolean;
+    resolveSectionLabels: (section: any) => {
+        title: any;
+        description: any;
+    };
+    resolveFieldLabels: (field: any, customData?: Record<string, any>) => any;
+    resolveFieldLength: (field: any, customData?: Record<string, any>) => any;
+    resolveDefaultValue: (field: any, customData?: Record<string, any>, contextPath?: string) => any;
+    getWizardTabs: (section: any) => any;
+    applyCalculations: () => void;
+    isSubmitDisabled: import("vue").ComputedRef<any>;
+    resolveSectionGridClass: (layout: any) => string;
+    resolveFieldColumnClass: (field: any, parentLayout?: string) => string;
+    t: import("vue-i18n").ComposerTranslation<{
+        [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+    }, string, import("@intlify/core-base").RemoveIndexSignature<{
+        [x: string]: import("vue-i18n").LocaleMessageValue<import("vue-i18n").VueMessageType>;
+    }>, never, never, never>;
+    locale: import("vue").ComputedRef<string>;
+    i18nLocale: import("vue").WritableComputedRef<string, string>;
+    apiUrl: any;
+    router: any;
+    isSubmitting: import("vue").Ref<boolean, boolean>;
+    internalSchema: import("vue").Ref<any, any>;
+    activeSchema: import("vue").ComputedRef<any>;
+    resolvedBaseUrl: import("vue").ComputedRef<any>;
+    permissionBase: import("vue").ComputedRef<any>;
+    checkPermission: ((permission: string) => boolean) | undefined;
+    userPermissions: any;
+    selectedTokenCore: any;
+    radioGroups: import("vue").ComputedRef<Record<string, any[]>>;
+    confirmDialog: {
+        visible: boolean;
+        title: string;
+        message: string;
+        action: any;
+        showCancel?: boolean;
+        okText?: string;
+        cancelText?: string;
+        isBlocking?: boolean;
+        redirectUrl?: string;
+    };
+    fieldMap: import("vue").ComputedRef<FieldMap>;
+    rawItemsCache: Record<string, any[]>;
+    revision: import("vue").Ref<number, number>;
+    formData: Record<string, any>;
+    originalData: Record<string, any>;
+    errors: Record<string, string>;
+    touched: Record<string, boolean>;
+    isSubmitted: import("vue").Ref<boolean, boolean>;
+    fieldErrors: Record<string, string | null>;
+    inlineState: Record<string, boolean>;
+    wizardState: Record<string, number>;
+    wizardResponses: Record<string, any>;
+    sectionLoading: Record<string, boolean>;
+    fieldLoading: Record<string, boolean>;
+    sectionPagination: Record<string, {
+        page: number;
+        perPage: number;
+        totalData?: number;
+        maxPage?: number;
+        filters?: Record<string, any>;
+    }>;
+    validation: import("./types/form.types").ValidationComposables;
+    getSectionKey: typeof getSectionKey;
+    sortedFields: (fields: any[]) => any[];
+    prefetchFieldItems: (field: any, force?: boolean, contextPath?: string, localData?: any) => Promise<void>;
+    fetchFormData: (force?: boolean) => Promise<void>;
+    fetchSectionData: (sectionKey: string, sectionObj?: any, contextPathOverride?: string) => Promise<void>;
+    getDeepValue: (obj: any, path: string) => any;
+    setDeepValue: (obj: any, path: string, val: any) => void;
+};

package/dist/types/composables/dynamic-form/utils/form.utils.d.ts

@@ -0,0 +1,21 @@
+export declare function getSectionKey(s: any): string;
+export declare const getDeepValue: (obj: any, path: string) => any;
+export declare const setDeepValue: (obj: any, path: string, val: any) => void;
+export declare const deepRaw: (val: any) => any;
+export declare const extractVars: (rule: any) => string[];
+export declare const sortedFields: (fields: any[]) => any[];
+export declare const flattenObject: (obj: any, res?: any, prefix?: string) => any;
+export declare const findModelValue: (obj: any, model: string) => any;
+export declare const mergeDeep: (target: any, source: any) => void;
+export declare const resolveEndpointUrl: (url: string, baseUrl?: any) => string;
+export declare const isRowEmpty: (row: any) => boolean;
+export declare const paginationStorageKey: (sectionKey: string, apiUrl: string) => string;
+export interface PaginationStorage {
+    load(key: string): any | null;
+    save(key: string, data: any): void;
+    clear(): void;
+}
+export declare const setPaginationStorage: (storage: PaginationStorage | null) => void;
+export declare const loadStoredPagination: (sectionKey: string, apiUrl: string) => any | null;
+export declare const saveStoredPagination: (sectionKey: string, apiUrl: string, data: any) => void;
+export declare const clearPaginationCache: () => void;

package/dist/types/composables/dynamic-form/validation/useFormValidation.d.ts

@@ -0,0 +1,3 @@
+import { UseFormValidationOptions } from "../../../types/dynamic.types";
+import { ValidationComposables } from "../types/form.types";
+export declare function useFormValidation({ formData, locale, errors, fieldMap, activeSchema, isSectionVisible, isSectionHidden, isFieldVisible, isFieldRequired, resolveFieldLength, }: UseFormValidationOptions): ValidationComposables;

package/dist/types/composables/dynamic-form/watcher/useFormWatcher.d.ts

@@ -0,0 +1,4 @@
+import { UseFormWatcherOptions } from "../../../types/dynamic.types";
+export declare function useFormWatcher(options: UseFormWatcherOptions): {
+    lastEmittedPayload: () => string;
+};

package/dist/types/composables/useAuthOverlay.d.ts

@@ -0,0 +1,91 @@
+export type LoginPhase = 'verifying' | 'success' | 'error';
+export interface AuthOverlayState {
+    isLoggingIn: boolean;
+    isLoggingOut: boolean;
+    loginPhase: LoginPhase;
+    loginTitle: string;
+    loginMessage: string;
+    loginUserName: string;
+    logoutTitle: string;
+    logoutMessage: string;
+    duration?: number;
+}
+export declare const authOverlayState: import("vue").Ref<{
+    isLoggingIn: boolean;
+    isLoggingOut: boolean;
+    loginPhase: LoginPhase;
+    loginTitle: string;
+    loginMessage: string;
+    loginUserName: string;
+    logoutTitle: string;
+    logoutMessage: string;
+    duration?: number | undefined;
+}, AuthOverlayState | {
+    isLoggingIn: boolean;
+    isLoggingOut: boolean;
+    loginPhase: LoginPhase;
+    loginTitle: string;
+    loginMessage: string;
+    loginUserName: string;
+    logoutTitle: string;
+    logoutMessage: string;
+    duration?: number | undefined;
+}>;
+/**
+ * Start login transition overlay (phase: 'verifying' by default)
+ */
+export declare const startLoginTransition: (userName?: string, title?: string, message?: string, phase?: LoginPhase) => void;
+/**
+ * Set login success phase (animates checkmark & auto-progress bar without requiring click)
+ */
+export declare const setLoginSuccess: (userName?: string, title?: string, message?: string) => void;
+/**
+ * Close/end login transition overlay
+ */
+export declare const endLoginTransition: () => void;
+/**
+ * Set login error phase with automatic progress bar countdown & auto-dismiss (no click needed)
+ */
+export declare const setLoginError: (message?: string, title?: string, duration?: number) => void;
+/**
+ * Start logout transition overlay (smooth exit door animation & auto progress bar)
+ */
+export declare const startLogout: (title?: string, message?: string) => void;
+/**
+ * End logout transition overlay
+ */
+export declare const endLogout: () => void;
+/**
+ * Composable helper
+ */
+export declare function useAuthOverlay(): {
+    state: import("vue").Ref<{
+        isLoggingIn: boolean;
+        isLoggingOut: boolean;
+        loginPhase: LoginPhase;
+        loginTitle: string;
+        loginMessage: string;
+        loginUserName: string;
+        logoutTitle: string;
+        logoutMessage: string;
+        duration?: number | undefined;
+    }, AuthOverlayState | {
+        isLoggingIn: boolean;
+        isLoggingOut: boolean;
+        loginPhase: LoginPhase;
+        loginTitle: string;
+        loginMessage: string;
+        loginUserName: string;
+        logoutTitle: string;
+        logoutMessage: string;
+        duration?: number | undefined;
+    }>;
+    isVisible: import("vue").ComputedRef<boolean>;
+    isLoginMode: import("vue").ComputedRef<boolean>;
+    startLogin: (userName?: string, title?: string, message?: string, phase?: LoginPhase) => void;
+    setLoginSuccess: (userName?: string, title?: string, message?: string) => void;
+    setLoginError: (message?: string, title?: string, duration?: number) => void;
+    endLogin: () => void;
+    startLogout: (title?: string, message?: string) => void;
+    endLogout: () => void;
+};

package/dist/types/composables/useMenuMetadata.d.ts

@@ -0,0 +1,7 @@
+export declare function useMenuMetadata(): {
+    setPageTitle: (title: string) => void;
+    setBreadcrumb: (items: Array<{
+        label: string;
+        path?: string;
+    }>) => void;
+};

package/dist/types/composables/useSmoothCaret.d.ts

@@ -0,0 +1,21 @@
+import { type CSSProperties, type Ref } from "vue";
+/**
+ * Smooth (animated) caret for single-line `<input>` elements.
+ *
+ * The native caret is hidden (via `caret-transparent`) and an overlay element
+ * glides between caret positions. The overlay must be rendered inside the
+ * input's parent element, and that parent must be `position: relative`.
+ *
+ * Password inputs are supported by calibrating the browser's mask glyph width.
+ * Falls back to the native caret when the input does not expose selection APIs
+ * (e.g. native `type="email"` — render it as `type="text"` + `inputmode="email"`).
+ * (e.g. native `type="email"` — render it as `type="text"` + `inputmode="email"`).
+ */
+export declare function useSmoothCaret(inputRef: Ref<HTMLInputElement | HTMLTextAreaElement | null>, enabled: Ref<boolean>): {
+    caretStyle: import("vue").ComputedRef<CSSProperties>;
+    caretVisible: import("vue").ComputedRef<boolean>;
+    hideNativeCaret: import("vue").ComputedRef<boolean>;
+    isCaretMoving: Ref<boolean, boolean>;
+    caretAnimate: Ref<boolean, boolean>;
+    refreshCaret: () => void;
+};

package/dist/types/composables/useTemplateDownload.d.ts

@@ -0,0 +1,40 @@
+import { type ComputedRef } from 'vue';
+export interface TemplateConfig {
+    endpoint?: {
+        apiUrl?: string;
+        apiMethod?: string;
+        params?: Record<string, any>;
+    };
+    fileType?: string;
+    filename?: string;
+    icon?: string;
+    labelID?: string;
+    labelEN?: string;
+    labelKR?: string;
+    titleID?: string;
+    titleEN?: string;
+    titleKR?: string;
+    descriptionID?: string;
+    descriptionEN?: string;
+    descriptionKR?: string;
+}
+export interface UseTemplateDownloadOptions {
+    template?: TemplateConfig;
+    locale: ComputedRef<string>;
+    apiUrl: any;
+}
+export declare function useTemplateDownload(options: UseTemplateDownloadOptions): {
+    isDownloading: import("vue").Ref<boolean, boolean>;
+    isExpanded: import("vue").Ref<boolean, boolean>;
+    downloadError: import("vue").Ref<string | null, string | null>;
+    hasTemplate: ComputedRef<boolean>;
+    resolvedIcon: ComputedRef<string>;
+    resolvedLabel: ComputedRef<string>;
+    resolvedTitle: ComputedRef<string>;
+    resolvedDescription: ComputedRef<string>;
+    toggleButtonText: ComputedRef<string>;
+    retryButtonText: ComputedRef<string>;
+    downloadTemplate: () => Promise<void>;
+    toggleExpanded: () => void;
+    clearError: () => void;
+};

package/dist/types/composables/useToast.d.ts

@@ -0,0 +1,93 @@
+export type ToastType = 'success' | 'error' | 'warning' | 'info' | 'loading';
+export interface ToastOptions {
+    type?: ToastType;
+    title?: string;
+    message?: string;
+    duration?: number;
+    confirmText?: string;
+    immediate?: boolean;
+    showButton?: boolean;
+    onConfirm?: () => void;
+}
+export interface ToastState {
+    isOpen: boolean;
+    type: ToastType;
+    title: string;
+    message: string;
+    confirmText?: string;
+    showButton?: boolean;
+    duration?: number;
+    onConfirm?: () => void;
+}
+export declare const toastState: import("vue").Ref<{
+    isOpen: boolean;
+    type: ToastType;
+    title: string;
+    message: string;
+    confirmText?: string | undefined;
+    showButton?: boolean | undefined;
+    duration?: number | undefined;
+    onConfirm?: (() => void) | undefined;
+}, ToastState | {
+    isOpen: boolean;
+    type: ToastType;
+    title: string;
+    message: string;
+    confirmText?: string | undefined;
+    showButton?: boolean | undefined;
+    duration?: number | undefined;
+    onConfirm?: (() => void) | undefined;
+}>;
+/**
+ * Close the alert modal
+ */
+export declare const closeToast: () => void;
+/**
+ * Show custom alert modal
+ */
+export declare const showToast: (options: ToastOptions) => void;
+/**
+ * Singleton toast object for direct import:
+ * import { toast } from '@skyworx/dynamic-ui'
+ */
+export declare const toast: {
+    success: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    error: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    warning: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    info: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    loading: (title?: string, message?: string) => void;
+    show: (options: ToastOptions) => void;
+    close: () => void;
+    remove: () => void;
+    clear: () => void;
+    clearAll: () => void;
+};
+/**
+ * Composable useToast()
+ */
+export declare function useToast(): {
+    success: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    error: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    warning: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    info: (titleOrMessage: string, messageOrTitle?: string, duration?: number, immediate?: boolean) => void;
+    loading: (title?: string, message?: string) => void;
+    show: (options: ToastOptions) => void;
+    close: () => void;
+    remove: () => void;
+    clear: () => void;
+    clearAll: () => void;
+};
+/**
+ * Compatibility exports for vue3-toastify
+ */
+export declare const dummyToastifyPlugin: {
+    install: () => void;
+};
+export default dummyToastifyPlugin;
+export declare const Vue3Toastify: {
+    install: () => void;
+};
+export declare const ToastContainer: {
+    name: string;
+    render: () => null;
+};

package/dist/types/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;