@nside/wefa 0.4.4 → 0.4.6

package/dist/src/containers/NavbarContainer/NavbarContainer.vue.d.ts

@@ -0,0 +1,6 @@
+import { GenericContainerProps } from '../helpers';
+export interface NavBarContainerProps extends GenericContainerProps {
+    depth?: number;
+}
+declare const _default: import('vue').DefineComponent<NavBarContainerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NavBarContainerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/containers/NavbarContainer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NavbarContainer } from './NavbarContainer.vue';
+export * from './NavbarContainer.vue';

package/dist/src/containers/RoutedTabsComponent/RoutedTabsComponent.vue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Props for the RoutedTabsComponent
+ */
+export interface RoutedTabsComponentProps {
+    /** Array of tab names that correspond to route names */
+    tabs: string[];
+}
+declare const _default: import('vue').DefineComponent<RoutedTabsComponentProps, {
+    activeTabIndex: import('vue').ComputedRef<number>;
+    onTabChange: (value: string | number) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RoutedTabsComponentProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/containers/RoutedTabsComponent/index.d.ts

@@ -0,0 +1 @@
+export { default as RoutedTabsComponent, type RoutedTabsComponentProps, } from './RoutedTabsComponent.vue';

package/dist/src/containers/SideMenuContainer/SideMenuContainer.vue.d.ts

@@ -0,0 +1,7 @@
+import { GenericContainerProps } from '../helpers';
+export interface SideMenuContainerProps extends GenericContainerProps {
+    depth?: 1 | 2;
+    width?: number;
+}
+declare const _default: import('vue').DefineComponent<SideMenuContainerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SideMenuContainerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/containers/SideMenuContainer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SideMenuContainer } from './SideMenuContainer.vue';
+export * from './SideMenuContainer.vue';

package/dist/src/containers/helpers.d.ts

@@ -0,0 +1,47 @@
+import { MenuItem } from 'primevue/menuitem';
+import { Ref } from 'vue';
+import { RouteLocationMatched, RouteRecordRaw, RouteLocationAsRelativeGeneric, RouteLocationAsPathGeneric } from 'vue-router';
+export interface GenericContainerProps {
+    depth?: number;
+    start?: {
+        logo?: string;
+        appName?: string;
+    };
+    end?: {
+        showUser: boolean;
+        showSettings: boolean;
+        showLogout: boolean;
+        settingsRoute: string | RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric;
+        logoutRoute: string | RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric;
+    };
+}
+/**
+ * Generates a list of PrimeVue-compatible MenuItem by inspecting children of a provided route
+ * @param routeLocationMatched route to inspect, obtain with useRoute().matched[routerViewDepth]
+ * @param depth how deep to recursively look for children, 1 is the base
+ * @returns MenuItem[] compatible with PrimeVue Menu components
+ */
+export declare function menuItemsFromRoute(routeLocationMatched: Ref<RouteLocationMatched>, depth?: number): MenuItem[];
+/**
+ * Sub function of menuItemsFromRoute, used to build MenuItem instances
+ * @param routeRecordRaw recursion node
+ * @param parentPath required to build full paths
+ * @param maxDepth recursion limiter
+ * @param currentDepth recursion accumulator
+ * @returns MenuItem instance
+ */
+export declare function itemizeRouteRecordRaw(routeRecordRaw: RouteRecordRaw, parentPath: string, maxDepth: number, currentDepth: number): MenuItem;
+/**
+ * Builds an end section to a PrimeVue-Menu-based component
+ * @param endProps "end" section of GenericContainerProps
+ * @returns MenuItem[] compatible with PrimeVue Menu components
+ */
+export declare function makeEndSectionMenuItems(endProps: GenericContainerProps['end']): MenuItem[];
+/**
+ * Set up a Router depth tracker, used by container components to extract their target route from the router
+ * This NEEDS to be called on any component with a <RouterView />
+ * Use like this :
+ * const targetRoute = useRoute().matched[routerViewDepth]
+ * @returns current routerViewDepth on a component instance.
+ */
+export declare function setupDepthTracker(): number;

package/dist/src/containers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './helpers';
+export * from './BareContainer';
+export * from './SideMenuContainer';
+export * from './NavbarContainer';
+export * from './RoutedTabsComponent';
+export * from './LayoutContainer';

package/dist/src/lib.d.ts

@@ -0,0 +1,24 @@
+import { App } from 'vue';
+import { Pinia } from 'pinia';
+import { default as PrimeVue } from 'primevue/config';
+export { PrimeVue as PrimeVueLibConfig };
+export * from '../components/AutoroutedBreadcrumb';
+export * from '../components/ControlBarComponent';
+export * from '../components/GanttChartComponent';
+export * from '../components/DashboardComponent';
+export * from '../components/FormComponent';
+export * from '../components/NetworkButton';
+export * from '../components/NotFound';
+export * from '../components/PlotlyComponent';
+export * from '../components/TableComponent';
+export * from '../theme';
+export * from '../stores';
+export * from '../plugins';
+export * from '../locales';
+export * from '../utils/markdown';
+declare const _default: {
+    install(app: App, options?: {
+        pinia?: Pinia;
+    }): void;
+};
+export default _default;

package/dist/src/locales/index.d.ts

@@ -0,0 +1,30 @@
+import { I18nOptions, LocaleMessages, LocaleMessageValue } from 'vue-i18n';
+/**
+ * Load project translation files dynamically (for consumer use)
+ * This function scans the specified glob pattern for JSON files in the locales directory,
+ * @param glob Glob pattern to match translation files
+ * @returns An object containing the loaded translations, structured by locale and root field.
+ */
+export declare function loadTranslations(glob?: Record<string, {
+    default: Record<string, LocaleMessageValue>;
+}> | undefined): LocaleMessages<Record<string, LocaleMessageValue>>;
+/**
+ * Create the i18n instance with merged messages
+ * This function merges library default translations with project-provided messages,
+ * allowing project overrides to take precedence.
+ * It supports dynamic loading of translations and provides a consistent i18n setup.
+ * @param options I18nOptions
+ * @returns I18n instance
+ */
+export declare function createLibI18n(options?: I18nOptions): import('vue-i18n').I18n<LocaleMessages<Record<string, LocaleMessageValue>>, {}, {}, string, true>;
+/**
+ * Composable for components to use i18n
+ * @returns An object with `t` and `mergeLocaleMessage` methods for translation and dynamic message merging.
+ */
+export declare function useI18nLib(): import('vue-i18n').Composer<{}, {}, {}, string, never, string>;
+/**
+ * Utility to add or override translations dynamically after creation
+ * @param locale The locale to register translations for
+ * @param messages The translation messages to add or override
+ */
+export declare function registerTranslations(locale: string, messages: LocaleMessages<LocaleMessageValue>): void;

package/dist/src/network/apiClient.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue';
+import { UseQueryReturnType, UseQueryOptions, UseMutationReturnType, UseMutationOptions } from '@tanstack/vue-query';
+import { AxiosError } from 'axios';
+/**
+ * Wraps a generic HTTP GET request (by URL) with TanStack useQuery.
+ * The API is called automatically again when the URL changes.
+ * The API is not called if the URL is ref(undefined).
+ * @param url ref to a string or undefined, the endpoint to call
+ * @param queryOptions TanStack useQuery options: https://tanstack.com/query/v5/docs/framework/vue/reference/useQuery
+ * @returns TanStack useQuery return: https://tanstack.com/query/v5/docs/framework/vue/reference/useQuery
+ *
+ * Example usage:
+ *   const { data, isLoading, error } = apiClient.query(ref('/api/get-data/'))
+ */
+declare function query(url: Ref<string | undefined>, queryOptions?: Omit<UseQueryOptions<unknown>, 'queryKey' | 'queryFn'>): UseQueryReturnType<any, AxiosError>;
+/**
+ * Wraps a generic HTTP POST request (by URL and body) with TanStack useMutation.
+ * The API is not called if the URL is ref(undefined).
+ * @param url ref to a string or undefined, the endpoint to call
+ * @param mutationOptions TanStack useMutation options: https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+ * @returns TanStack useMutation return: https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+ *
+ * Example usage:
+ *   const mutation = apiClient.mutation(ref('/api/post-data/'))
+ *   mutation.mutate({ foo: 'bar' })
+ */
+declare function mutation(url: Ref<string | undefined>, mutationOptions?: Omit<UseMutationOptions<unknown, AxiosError, any>, 'mutationFn'>): UseMutationReturnType<unknown, AxiosError, any, unknown>;
+declare const _default: {
+    query: typeof query;
+    mutation: typeof mutation;
+};
+export default _default;

package/dist/src/network/axios.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance } from 'axios';
+export declare const BACKEND_BASE_URL: string;
+declare const axiosInstance: AxiosInstance;
+export default axiosInstance;

package/dist/src/network/index.d.ts

@@ -0,0 +1,3 @@
+export { default as axiosInstance } from './axios';
+export { default as apiClient } from './apiClient';
+export { default as typedApiClient } from './typedApiClient';

package/dist/src/network/typedApiClient.d.ts

@@ -0,0 +1,58 @@
+import { UseQueryReturnType, UseQueryOptions, UseMutationReturnType, UseMutationOptions } from '@tanstack/vue-query';
+import { AxiosError, AxiosInstance } from 'axios';
+import { Ref } from 'vue';
+/**
+ * Attaches an axios instance to an OpenAPI Client/SDK,
+ * autogenerated by @hey-api/openapi-ts.
+ * You need to call this during application startup to have a working OpenAPI Client
+ * E.g., if you're running: npx @hey-api/openapi-ts --input .path/to/openapi.yaml --output ./src/openapi
+ * Then you will have your generated code in @/openapi, and then you can:
+ * import { client } from '@/openapi/client.gen'
+ * import { typedApiClient } from '@nside/wefa/network'
+ * typedApiClient.setupOpenApiClient(client)
+ * @param client Auto-generated OpenAPI client
+ * @param axios Optional axios instance. If not provided, it defaults to the axios singleton.
+ */
+declare function setupOpenApiClient(client: any, axios?: AxiosInstance): void;
+type ExtractQueryOptionsType<T> = T extends (options: infer O) => any ? O : never;
+type ExtractQueryDataType<T> = T extends (options: any) => Promise<{
+    data: infer D;
+}> ? D : T extends (options: any) => {
+    data: infer D;
+} ? D : never;
+/**
+ * Wraps a auto-generated OpenAPI query with TanStack useQuery,
+ * providing many state-management helpers around the query
+ * @param callable Auto-generated function from an GET endpoint, using @hey-api/openapi-ts
+ * @param options reactive options expected by and passed to the callable, e.g to build the URL. If ref(undefined) is provided, the query is not called
+ * @param queryOptions TanStack useQuery options : https://tanstack.com/query/v5/docs/framework/vue/reference/useQuery
+ * @returns TanStack useQuery return : https://tanstack.com/query/v5/docs/framework/vue/reference/useQuery
+ */
+export declare function query<TCallable extends (options: any) => any, TOptions extends ExtractQueryOptionsType<TCallable>, TData extends ExtractQueryDataType<TCallable>>(callable: TCallable, options: Ref<TOptions | undefined>, queryOptions?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>): UseQueryReturnType<TData, Error>;
+type ExtractMutationOptionsType<T> = T extends (options: infer O) => any ? O : never;
+type ExtractMutationDataType<T> = T extends (options: any) => Promise<{
+    data: infer D;
+}> ? D : T extends (options: any) => {
+    data: infer D;
+} ? D : never;
+/**
+ * Wraps an auto-generated OpenAPI mutation (POST/PUT/DELETE) with TanStack useMutation,
+ * providing state-management helpers and lifecycle hooks for the mutation.
+ * @param callable Auto-generated function from a mutation endpoint (POST/PUT/DELETE), using @hey-api/openapi-ts
+ * @param mutationOptions TanStack useMutation options: https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+ * @returns TanStack useMutation return: https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation
+ *
+ * Example usage:
+ *   const mutation = typedApiClient.mutation(postHello, {
+ *     onSuccess: (data) => { ... },
+ *     onError: (error) => { ... }
+ *   })
+ *   mutation.mutate(options)
+ */
+export declare function mutation<TCallable extends (options: any) => any, TOptions extends ExtractMutationOptionsType<TCallable>, TData extends ExtractMutationDataType<TCallable>>(callable: TCallable, mutationOptions?: Omit<UseMutationOptions<TData, AxiosError, TOptions>, 'mutationFn'>): UseMutationReturnType<TData, AxiosError, TOptions, unknown>;
+declare const _default: {
+    query: typeof query;
+    mutation: typeof mutation;
+    setupOpenApiClient: typeof setupOpenApiClient;
+};
+export default _default;

package/dist/src/plugins/cookies/index.d.ts

@@ -0,0 +1,51 @@
+import { App, Ref } from 'vue';
+type CookieType = 'Essential' | 'Performance' | 'Analytics' | 'Advertising';
+export interface CookieConfiguration {
+    type: CookieType;
+    key: string;
+    name: string;
+    description: string;
+}
+export interface CookiesPluginOptions {
+    cookies: CookieConfiguration[];
+}
+export interface CookieConsent {
+    key: string;
+    consent: string;
+}
+export interface Cookie {
+    configuration: CookieConfiguration;
+    consent: boolean;
+}
+export declare const cookiesPlugin: {
+    install(app: App, options: CookiesPluginOptions): void;
+};
+export declare const useCookiesStore: import('pinia').StoreDefinition<"cookiesStore", Pick<{
+    initialize: (cookieConfigurations: CookieConfiguration[]) => void;
+    reviewNeeded: Ref<boolean, boolean>;
+    cookies: Ref<Cookie[], Cookie[]>;
+    showDialog: () => void;
+    acceptAllCookies: () => void;
+    rejectAllCookies: () => void;
+    saveCookiePreferences: () => void;
+    toggleDialog: Ref<boolean, boolean>;
+}, "reviewNeeded" | "cookies" | "toggleDialog">, Pick<{
+    initialize: (cookieConfigurations: CookieConfiguration[]) => void;
+    reviewNeeded: Ref<boolean, boolean>;
+    cookies: Ref<Cookie[], Cookie[]>;
+    showDialog: () => void;
+    acceptAllCookies: () => void;
+    rejectAllCookies: () => void;
+    saveCookiePreferences: () => void;
+    toggleDialog: Ref<boolean, boolean>;
+}, never>, Pick<{
+    initialize: (cookieConfigurations: CookieConfiguration[]) => void;
+    reviewNeeded: Ref<boolean, boolean>;
+    cookies: Ref<Cookie[], Cookie[]>;
+    showDialog: () => void;
+    acceptAllCookies: () => void;
+    rejectAllCookies: () => void;
+    saveCookiePreferences: () => void;
+    toggleDialog: Ref<boolean, boolean>;
+}, "initialize" | "showDialog" | "acceptAllCookies" | "rejectAllCookies" | "saveCookiePreferences">>;
+export {};

package/dist/src/plugins/cookies/views/CookieBar.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, {}, any>;
+export default _default;

package/dist/src/plugins/cookies/views/CookiesConsent.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, {}, any>;
+export default _default;

package/dist/src/plugins/index.d.ts

@@ -0,0 +1 @@
+export { default as legalConsentPlugin, defaultPrivacyNoticeRoute, defaultLegalConsentRoute, defaultTermsOfUseRoute, useLegalStore, type LegalConsent, type LegalConsentOptions, } from './legalConsent';

package/dist/src/plugins/legalConsent/index.d.ts

@@ -0,0 +1,89 @@
+import { App, Ref } from 'vue';
+import { Router, RouteRecordRaw } from 'vue-router';
+import { BackendStore } from '../../../stores';
+/**
+ * Represents the legal consent status for a user
+ */
+export interface LegalConsent {
+    /** Version number of the legal consent document */
+    version: number;
+    /** Date when the consent was accepted (ISO string from API or Date object in app) */
+    accepted_at: string | Date;
+    /** Whether the current consent is still valid */
+    valid: boolean;
+}
+/**
+ * Configuration options for the legal consent plugin
+ */
+export interface LegalConsentOptions {
+    /** Backend store instance for managing authentication state */
+    backendStore: BackendStore;
+    /** Vue Router instance for route management */
+    router: Router;
+    /** API endpoint path for legal consent operations */
+    path: string;
+    /** Custom route configuration for terms of use page (optional) */
+    termsOfUseRoute?: RouteRecordRaw;
+    /** Custom route configuration for privacy notice page (optional) */
+    privacyNoticeRoute?: RouteRecordRaw;
+    /** Custom route configuration for legal consent page (optional) */
+    legalConsentRoute?: RouteRecordRaw;
+}
+/** Default route configuration for terms of use page */
+export declare const defaultTermsOfUseRoute: RouteRecordRaw;
+/** Default route configuration for privacy notice page */
+export declare const defaultPrivacyNoticeRoute: RouteRecordRaw;
+/** Default route configuration for legal consent page */
+export declare const defaultLegalConsentRoute: RouteRecordRaw;
+/**
+ * Vue plugin for legal consent management
+ *
+ * This plugin provides comprehensive legal consent functionality, including:
+ * - Route management for terms of use, privacy notice, and consent pages
+ * - Navigation guards to enforce consent requirements
+ * - Store integration for consent state management
+ * - Automatic route registration and backend integration
+ * @example
+ * ```typescript
+ * app.use(legalConsentPlugin, {
+ *   backendStore: myBackendStore,
+ *   router: myRouter,
+ *   path: 'api/legal'
+ * })
+ * ```
+ */
+export declare const legalConsentPlugin: {
+    /**
+     * Installs the legal consent plugin
+     * @param app - Vue application instance
+     * @param options - Plugin configuration options
+     */
+    install(app: App, options: LegalConsentOptions): Promise<void>;
+};
+export default legalConsentPlugin;
+/**
+ * Pinia store for managing legal consent state and operations
+ *
+ * This store handles:
+ * - Storing current legal consent status
+ * - Managing API endpoint configuration
+ * - Fetching consent data from backend
+ * - Accepting legal consent
+ * - Watching for authentication changes to trigger consent fetching
+ */
+export declare const useLegalStore: import('pinia').StoreDefinition<"legalStore", Pick<{
+    legalEndpoint: Ref<string | undefined, string | undefined>;
+    legalConsent: Ref<LegalConsent | null, LegalConsent | null>;
+    fetchLegalConsent: () => Promise<void>;
+    acceptLegalConsent: () => Promise<void>;
+}, "legalEndpoint" | "legalConsent">, Pick<{
+    legalEndpoint: Ref<string | undefined, string | undefined>;
+    legalConsent: Ref<LegalConsent | null, LegalConsent | null>;
+    fetchLegalConsent: () => Promise<void>;
+    acceptLegalConsent: () => Promise<void>;
+}, never>, Pick<{
+    legalEndpoint: Ref<string | undefined, string | undefined>;
+    legalConsent: Ref<LegalConsent | null, LegalConsent | null>;
+    fetchLegalConsent: () => Promise<void>;
+    acceptLegalConsent: () => Promise<void>;
+}, "fetchLegalConsent" | "acceptLegalConsent">>;

package/dist/src/plugins/legalConsent/views/LegalConsent.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, {}, HTMLElement>;
+export default _default;

package/dist/src/plugins/legalConsent/views/LegalDocument.vue.d.ts

@@ -0,0 +1,8 @@
+export interface LegalDocumentProps {
+    classes?: string;
+    documentEndpoint: string;
+}
+declare const _default: import('vue').DefineComponent<LegalDocumentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LegalDocumentProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    'legal-document': HTMLDivElement;
+}, HTMLElement>;
+export default _default;

package/dist/src/router/guards.d.ts

@@ -0,0 +1,28 @@
+import { RouteLocationNormalized, NavigationGuardNext, RouteLocationRaw, RouteLocationNormalizedLoaded } from 'vue-router';
+/**
+ * Checks that users are authenticated before navigating to routes with meta.wefa.requiresAuth
+ * If the check fails, users are redirected to the route specified in redirect
+ * This is useful if you want to prevent users from accessing your app if they're not authenticated
+ * @param to RouteLocationNormalized, pass as-is from router.beforeEach
+ * @param from RouteLocationNormalizedLoaded, pass as-is from router.beforeEach
+ * @param next NavigationGuardNext, pass as-is from router.beforeEach
+ * @param redirect RouteLocationRaw to be used if guard check fails, default is {name: libRouteRecords.login.name}
+ */
+export declare function requiresAuth(to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext, redirect?: RouteLocationRaw): void;
+/**
+ * Checks that users are unauthenticated before navigating to routes with meta.wefa.requiresUnauth
+ * If the check fails, users are redirected to the route specified in redirect
+ * This is useful e.g if you want your users to skip the login page if they're already logged in
+ * @param to RouteLocationNormalized, pass as-is from router.beforeEach
+ * @param from RouteLocationNormalizedLoaded, pass as-is from router.beforeEach
+ * @param next NavigationGuardNext, pass as-is from router.beforeEach
+ * @param redirect RouteLocationRaw to be used if guard check fails, default is {path: '/'}
+ */
+export declare function requiresUnauth(to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext, redirect?: RouteLocationRaw): void;
+/**
+ * Runs the default route guards provided by the lib
+ * @param to RouteLocationNormalized
+ * @param from RouteLocationNormalizedLoaded
+ * @param next NavigationGuardNext
+ */
+export declare function defaultRouteGuards(to: RouteLocationNormalized, from: RouteLocationNormalizedLoaded, next: NavigationGuardNext): void;

package/dist/src/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { libRouteRecords } from './libRoutes';
+export * from './guards';

package/dist/src/router/libRoutes.d.ts

@@ -0,0 +1,2 @@
+import { WeFaRouteRecordRaw } from './types';
+export declare const libRouteRecords: Record<'login' | 'logout', WeFaRouteRecordRaw>;

package/dist/src/router/types.d.ts

@@ -0,0 +1,31 @@
+import { RouteMeta, RouteRecordRaw } from 'vue-router';
+export interface WeFaRouteMeta {
+    title: string;
+    icon?: string;
+    requiresAuth?: boolean;
+    requiresUnauth?: boolean;
+    showInNavigation?: boolean;
+    section?: string;
+}
+export type WeFaRouteRecordRaw = RouteRecordRaw & {
+    meta: RouteMeta & {
+        wefa: WeFaRouteMeta;
+    };
+};
+/**
+ * Augment vue-router's RouteMeta globally so every route can carry WeFa metadata.
+ *
+ * Why:
+ * - Vue Router exposes `route.meta` as a shared interface (`RouteMeta`).
+ * - We add `wefa` to that interface so `route.meta.wefa` is type-safe everywhere
+ *   (guards, containers, breadcrumb, stories, etc.).
+ *
+ * Notes:
+ * - `wefa` is optional (`?`) because not every route must define it.
+ * - This is type-only: it changes TypeScript checking/autocomplete, not runtime behavior.
+ */
+declare module 'vue-router' {
+    interface RouteMeta {
+        wefa?: WeFaRouteMeta;
+    }
+}

package/dist/src/stores/backend/common.d.ts

@@ -0,0 +1,17 @@
+import { Ref, WatchHandle } from 'vue';
+import { Router } from 'vue-router';
+export interface CommonAuthFunctions {
+    setPostLogin: (fn: () => void) => void;
+    setPostLogout: (fn: () => void) => void;
+    setupAuthRouteGuard: (router: Router) => void;
+    unsetAuthRouteGuard: () => void;
+    authRouteGuardWatcher?: WatchHandle | null;
+}
+/**
+ * Creates common authentication functions that can be shared between different authentication implementations.
+ * @param authenticated - Reactive reference to the authentication state
+ * @param postLogin - Reactive reference to the post-login callback
+ * @param postLogout - Reactive reference to the post-logout callback
+ * @returns An object containing common authentication functions
+ */
+export declare function createCommonAuthFunctions(authenticated: Ref<boolean>, postLogin: Ref<() => void>, postLogout: Ref<() => void>): CommonAuthFunctions;

package/dist/src/stores/backend/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A constant variable used as the key for storing and retrieving the authentication token
+ * in the browser's localStorage. This key is utilized to maintain user session or
+ * authentication state across browser sessions by securely saving the token locally.
+ */
+export declare const localStorageKey = "authenticationToken";
+/**
+ * Constants used as keys for storing and retrieving JWT authentication tokens
+ * in the browser's localStorage. These keys are utilized to maintain user session or
+ * authentication state across browser sessions by securely saving the tokens locally.
+ */
+export declare const jwtAccessTokenKey = "jwtAccessToken";
+export declare const jwtRefreshTokenKey = "jwtRefreshToken";
+export declare const tokenLoginEndpoint = "/api/token-auth/";
+export declare const jwtLoginEndpoint = "/api/token/";
+export declare const jwtRefreshEndpoint = "/api/token/refresh/";
+export declare const oauthLoginEndpoint = "/proxy/api/auth/login";
+export declare const oauthLogoutEndpoint = "/proxy/api/auth/logout";
+export declare const oauthSessionEndpoint = "/proxy/api/auth/session";

package/dist/src/stores/backend/schemes/jwt.d.ts

@@ -0,0 +1,22 @@
+import { BackendStore, BackendStoreOptions } from '../types.ts';
+/**
+ * Configures and sets up a JWT-based authentication backend store for managing API authentication.
+ *
+ * The method initializes authentication states, such as access and refresh tokens, login/logout handlers, and
+ * authentication interceptors on the axios instance for requests and responses.
+ * It also provides helper functions for handling authentication processes, like login, logout,
+ * and post-login/logout callbacks. Additionally, it enables the setting of route guards to
+ * respond to authentication status changes in a Vue.js application.
+ *
+ * This implementation is designed to work with a backend offering JWT mechanism.
+ * @param backendStoreOptions - Runtime configuration for endpoints and JWT-specific auth hooks.
+ * @returns An object containing authentication state, API client instance, and helper functions:
+ * - `axiosInstance`: Pre-configured axios instance with authentication support
+ * - `authenticated`: Reactive flag representing the authentication status
+ * - `login`: Function to authenticate users using credentials
+ * - `logout`: Function to deauthenticate users and clear authentication tokens
+ * - `setPostLogin`: Method to set a callback function invoked after successful login
+ * - `setPostLogout`: Method to set a callback function invoked after logout
+ * - `setupAuthRouteGuard`: Function to set up route guard for managing authentication-driven route reevaluations
+ */
+export declare function jwtAuthenticationBackendStoreSetup(backendStoreOptions: BackendStoreOptions): BackendStore;

package/dist/src/stores/backend/schemes/oauth.d.ts

@@ -0,0 +1,14 @@
+import { BackendStore, BackendStoreOptions } from '../types.ts';
+/**
+ * Configures and sets up an OAuth session-based authentication backend store.
+ *
+ * This implementation expects a Backend-for-Frontend (BFF) to manage OAuth login/logout flows and session cookies.
+ * It checks session state on initialization, initiates login when no session exists, and
+ * ensures axios requests include credentials.
+ *
+ * Consuming apps should call `useBackendStore` once at app startup, or ensure it is created
+ * before route guards run, so session state is resolved early.
+ * @param backendStoreOptions - Store configuration, including OAuth endpoint overrides and redirect handler.
+ * @returns An object containing authentication state, API client instance, and helper functions:
+ */
+export declare function oauthAuthenticationBackendStoreSetup(backendStoreOptions: BackendStoreOptions): BackendStore;

package/dist/src/stores/backend/schemes/token.d.ts

@@ -0,0 +1,20 @@
+import { BackendStore, BackendStoreOptions } from '../types.ts';
+/**
+ * Configures and sets up a token-based authentication backend store for managing API authentication.
+ *
+ * The method initializes authentication states, such as tokens, login/logout handlers, and
+ * authentication interceptors on the axiosInstance for requests and responses.
+ * It also provides helper functions for handling authentication processes, like login, logout,
+ * and post-login/logout callbacks. Additionally, it enables the setting of route guards to
+ * respond to authentication status changes in a Vue.js application.
+ * @param backendStoreOptions - Runtime configuration for endpoints and token-based auth hooks.
+ * @returns An object containing authentication state, API client instance, and helper functions:
+ * - `axiosInstance`: Pre-configured axios instance with authentication support
+ * - `authenticated`: Reactive flag representing the authentication status
+ * - `login`: Function to authenticate users using credentials
+ * - `logout`: Function to deauthenticate users and clear authentication tokens
+ * - `setPostLogin`: Method to set a callback function invoked after successful login
+ * - `setPostLogout`: Method to set a callback function invoked after logout
+ * - `setupAuthRouteGuard`: Function to set up route guard for managing authentication-driven route reevaluations
+ */
+export declare function tokenAuthenticationBackendStoreSetup(backendStoreOptions: BackendStoreOptions): BackendStore;