@illuminateeducation/dna-atd-frontend 1.0.1-DNAATD-2189.0 → 1.0.2-DNAATD-3045-v3-POC.0

package/dist/src/App.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/src/components/common/BaseButton.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "click", ...args: any[]) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};

package/dist/src/components/common/BaseInput.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "update:modelValue", ...args: any[]) => void;
+    modelValue: string;
+    $props: {
+        readonly modelValue?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLInputElement>;
+export default _default;

package/dist/src/components/common/BaseModal.vue.d.ts

@@ -0,0 +1,19 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    show: boolean;
+    $props: {
+        readonly show?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};

package/dist/src/components/common/ErrorBoundary.vue.d.ts

@@ -0,0 +1,37 @@
+type __VLS_Props = {
+    /**
+     * When true, let the error propagate to ancestor boundaries and the global Vue handler.
+     * Default false to avoid duplicate reporting.
+     */
+    propagate?: boolean;
+    /**
+     * Change this value to reset the boundary state.
+     */
+    resetKey?: string | number;
+};
+declare function reset(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        fallback?(_: {
+            error: unknown;
+            info: string | undefined;
+            reset: typeof reset;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    propagate: boolean;
+    resetKey: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/composables/useAsync.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file useAsync.ts
+ * @description Vue composable for managing asynchronous operations with loading and error states
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Wraps async functions with loading state management
+ * - Handles error catching and reporting
+ * - Provides reactive data, error, and loading states
+ * - Simplifies async operation handling in components
+ * - Ensures proper cleanup and state management
+ */
+type AsyncFn<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
+/**
+ * Composable for handling async operations
+ */
+export declare function useAsync<TArgs extends unknown[], TResult>(asyncFunction: AsyncFn<TArgs, TResult>): {
+    data: [TResult | null] extends [import('vue').Ref<any, any>] ? import('@vue/shared').IfAny<import('vue').Ref<any, any> & TResult, import('vue').Ref<import('vue').Ref<any, any> & TResult, import('vue').Ref<any, any> & TResult>, import('vue').Ref<any, any> & TResult> : import('vue').Ref<import('vue').UnwrapRef<TResult> | null, TResult | import('vue').UnwrapRef<TResult> | null>;
+    error: import('vue').Ref<unknown, unknown>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    execute: (...args: TArgs) => Promise<any>;
+};
+export {};

package/dist/src/composables/useClickOutside.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+/**
+ * Composable for detecting clicks outside an element
+ */
+export declare function useClickOutside(callback: () => void): {
+    elementRef: Ref<HTMLElement | null>;
+};

package/dist/src/composables/useForm.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @file useForm.ts
+ * @description Vue composable for comprehensive form state management and validation
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Manages form data state reactively
+ * - Implements field-level and form-level validation
+ * - Tracks touched fields for better UX
+ * - Handles blur and change events
+ * - Provides form reset functionality
+ * - Exposes methods for programmatic field updates
+ * - Validates against custom rule sets
+ */
+export type ValidationRule<TValue = unknown> = {
+    validator: (value: TValue) => boolean;
+    message: string;
+};
+export type ValidationRules<TForm extends Record<string, unknown>> = Partial<{
+    [K in keyof TForm]: Array<ValidationRule<TForm[K]>>;
+}>;
+/**
+ * Composable for form validation
+ */
+export declare function useForm<TForm extends Record<string, unknown>>(initialValues?: TForm, validationRules?: ValidationRules<TForm>): {
+    formData: [TForm] extends [import('vue').Ref<any, any>] ? import('@vue/shared').IfAny<TForm, import('vue').Ref<TForm, TForm>, TForm> : import('vue').Ref<import('vue').UnwrapRef<TForm>, TForm | import('vue').UnwrapRef<TForm>>;
+    errors: [Partial<Record<keyof TForm, string>>] extends [import('vue').Ref<any, any>] ? import('@vue/shared').IfAny<import('vue').Ref<any, any> & Partial<Record<keyof TForm, string>>, import('vue').Ref<import('vue').Ref<any, any> & Partial<Record<keyof TForm, string>>, import('vue').Ref<any, any> & Partial<Record<keyof TForm, string>>>, import('vue').Ref<any, any> & Partial<Record<keyof TForm, string>>> : import('vue').Ref<import('vue').UnwrapRef<Partial<Record<keyof TForm, string>>>, Partial<Record<keyof TForm, string>> | import('vue').UnwrapRef<Partial<Record<keyof TForm, string>>>>;
+    touched: [Partial<Record<keyof TForm, boolean>>] extends [import('vue').Ref<any, any>] ? import('@vue/shared').IfAny<import('vue').Ref<any, any> & Partial<Record<keyof TForm, boolean>>, import('vue').Ref<import('vue').Ref<any, any> & Partial<Record<keyof TForm, boolean>>, import('vue').Ref<any, any> & Partial<Record<keyof TForm, boolean>>>, import('vue').Ref<any, any> & Partial<Record<keyof TForm, boolean>>> : import('vue').Ref<import('vue').UnwrapRef<Partial<Record<keyof TForm, boolean>>>, Partial<Record<keyof TForm, boolean>> | import('vue').UnwrapRef<Partial<Record<keyof TForm, boolean>>>>;
+    isValid: import('vue').ComputedRef<boolean>;
+    validateField: (fieldName: keyof TForm) => boolean;
+    validateForm: () => boolean;
+    handleBlur: (fieldName: keyof TForm) => void;
+    handleChange: <K extends keyof TForm>(fieldName: K, value: TForm[K]) => void;
+    resetForm: () => void;
+    setFieldValue: <K extends keyof TForm>(fieldName: K, value: TForm[K]) => void;
+    setFieldError: (fieldName: keyof TForm, error: string) => void;
+};

package/dist/src/composables/useLocalStorage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file useLocalStorage.ts
+ * @description Vue composable for reactive browser localStorage management
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Provides reactive interface to browser localStorage
+ * - Handles JSON serialization/deserialization
+ * - Implements safe read/write operations with error handling
+ * - Manages default values when keys don't exist
+ * - Exposes remove functionality for cleanup
+ * - Initializes data on component mount
+ */
+type StorageValue = unknown;
+/**
+ * Composable for managing localStorage
+ */
+export declare function useLocalStorage<T = StorageValue>(key: string, defaultValue?: T | null): {
+    data: [T | null] extends [import('vue').Ref<any, any>] ? import('@vue/shared').IfAny<import('vue').Ref<any, any> & T, import('vue').Ref<import('vue').Ref<any, any> & T, import('vue').Ref<any, any> & T>, import('vue').Ref<any, any> & T> : import('vue').Ref<import('vue').UnwrapRef<T> | null, T | import('vue').UnwrapRef<T> | null>;
+    write: (value: T | null) => void;
+    remove: () => void;
+};
+export {};

package/dist/src/composables/useWindowSize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file useWindowSize.ts
+ * @description Vue composable for reactive window size tracking with debouncing
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Tracks browser window width and height reactively
+ * - Implements debounced resize listener for performance
+ * - Updates reactive values on window resize
+ * - Manages resize event listener lifecycle
+ * - Useful for responsive layouts and conditional rendering
+ */
+/**
+ * Composable for tracking window size
+ */
+export declare function useWindowSize(): {
+    width: import('vue').Ref<number, number>;
+    height: import('vue').Ref<number, number>;
+};

package/dist/src/config/app.config.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @file app.config.ts
+ * @description Central application configuration file for DNA ATD Frontend
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Defines application-wide configuration constants
+ * - Manages API endpoint and timeout settings
+ * - Configures theme options and layout dimensions
+ * - Sets pagination defaults and date format preferences
+ * - Defines localStorage key conventions
+ * - Manages feature flags for conditional features
+ * - Establishes validation rules for user inputs
+ */
+export type AppConfig = {
+    name: string;
+    version: string;
+    api: {
+        baseURL: string;
+        timeout: number;
+        headers: Record<string, string>;
+    };
+    theme: {
+        default: 'light' | 'dark' | 'auto';
+        available: Array<'light' | 'dark' | 'auto'>;
+    };
+    layout: {
+        sidebarWidth: number;
+        headerHeight: number;
+        footerHeight: number;
+    };
+    pagination: {
+        defaultPageSize: number;
+        pageSizeOptions: number[];
+    };
+    dateFormat: {
+        short: string;
+        long: string;
+        time: string;
+    };
+    storageKeys: {
+        theme: string;
+        locale: string;
+        token: string;
+        user: string;
+    };
+    features: {
+        darkMode: boolean;
+        notifications: boolean;
+        analytics: boolean;
+    };
+    validation: {
+        password: {
+            minLength: number;
+            requireUppercase: boolean;
+            requireLowercase: boolean;
+            requireNumbers: boolean;
+            requireSpecialChars: boolean;
+        };
+        username: {
+            minLength: number;
+            maxLength: number;
+        };
+    };
+};
+export declare const appConfig: AppConfig;

package/dist/src/context/backendContext.d.ts

@@ -0,0 +1,9 @@
+import { App as VueApp, InjectionKey } from 'vue';
+import { BackendConfig, BackendUser } from '../types/backend';
+export type BackendContext<TConfig extends BackendConfig = BackendConfig, TUser extends BackendUser = BackendUser> = {
+    config: TConfig;
+    user: TUser;
+};
+export declare const backendContextKey: InjectionKey<BackendContext>;
+export declare function provideBackendContext(app: VueApp, context: BackendContext): void;
+export declare function useBackendContext<TConfig extends BackendConfig = BackendConfig, TUser extends BackendUser = BackendUser>(): BackendContext<TConfig, TUser>;

package/dist/src/features/admin/customization/composables/useCustomization.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file useCustomization.ts
+ * @description Vue composable for accessing customization store functionality
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Provides reactive access to customization store state
+ * - Exposes settings and loading states to components
+ * - Wraps store actions for fetching and updating settings
+ * - Ensures reactivity using storeToRefs
+ * - Simplifies customization feature integration in components
+ */
+export declare function useCustomization(): {
+    settings: import('vue').Ref<import('../store/customizationStore').CustomizationSettings, import('../store/customizationStore').CustomizationSettings>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchSettings: () => Promise<void>;
+    updateSettings: (newSettings: import('../store/customizationStore').CustomizationSettings) => void;
+};

package/dist/src/features/admin/customization/store/customizationStore.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file customizationStore.ts
+ * @description Pinia store for managing customization settings and preferences
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @store customization
+ * @responsibilities
+ * - Manages application customization settings state
+ * - Handles fetching and updating of user/admin customization preferences
+ * - Provides centralized loading state for customization operations
+ * - Exposes settings data and update methods to components
+ */
+export type CustomizationSettings = Record<string, unknown>;
+export declare const useCustomizationStore: import('pinia').StoreDefinition<"customization", Pick<{
+    settings: import('vue').Ref<CustomizationSettings, CustomizationSettings>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchSettings: () => Promise<void>;
+    updateSettings: (newSettings: CustomizationSettings) => void;
+}, "isLoading" | "settings">, Pick<{
+    settings: import('vue').Ref<CustomizationSettings, CustomizationSettings>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchSettings: () => Promise<void>;
+    updateSettings: (newSettings: CustomizationSettings) => void;
+}, never>, Pick<{
+    settings: import('vue').Ref<CustomizationSettings, CustomizationSettings>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchSettings: () => Promise<void>;
+    updateSettings: (newSettings: CustomizationSettings) => void;
+}, "fetchSettings" | "updateSettings">>;

package/dist/src/features/admin/customization/views/CustomizationView.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/src/features/admin/validation/composables/useValidation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file useValidation.ts
+ * @description Vue composable for accessing validation store functionality
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @responsibilities
+ * - Provides reactive access to validation store state
+ * - Exposes validation data and loading states to components
+ * - Wraps store actions for validation data fetching
+ * - Ensures reactivity using storeToRefs
+ * - Simplifies validation feature integration in components
+ */
+export declare function useValidation(): {
+    data: import('vue').Ref<import('../store/validationStore').ValidationItem[], import('../store/validationStore').ValidationItem[]>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchData: () => Promise<void>;
+};

package/dist/src/features/admin/validation/store/validationStore.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file validationStore.ts
+ * @description Pinia store for managing validation feature state and actions
+ * @author Illuminate Education
+ * @lastUpdated 2025-12-21
+ *
+ * @store validation
+ * @responsibilities
+ * - Manages validation data state across the application
+ * - Handles async data fetching for validation features
+ * - Provides centralized loading state management
+ * - Exposes validation data to components via Pinia composition API
+ */
+export type ValidationItem = Record<string, unknown>;
+export declare const useValidationStore: import('pinia').StoreDefinition<"validation", Pick<{
+    data: import('vue').Ref<ValidationItem[], ValidationItem[]>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchData: () => Promise<void>;
+}, "data" | "isLoading">, Pick<{
+    data: import('vue').Ref<ValidationItem[], ValidationItem[]>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchData: () => Promise<void>;
+}, never>, Pick<{
+    data: import('vue').Ref<ValidationItem[], ValidationItem[]>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    fetchData: () => Promise<void>;
+}, "fetchData">>;

package/dist/src/features/admin/validation/views/ValidationView.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;