forlogic-core 2.2.8 → 2.3.1

package/dist/sign/audit-trail/types.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Audit Trail Types
+ * Ported from Angular v1 (qex-audit-trail-readable) and v2 (flc-audit-trail)
+ *
+ * @example
+ * const value: AuditTrail = {} as AuditTrail;
+ */
+export interface AuditTrail {
+    documentId: string;
+    eventName: string;
+    entityName: string;
+    entityTypeName: string;
+    software: string;
+    dateTime: string;
+    userEmail: string;
+    userName: string;
+    ip: string;
+    isMobileRequest: boolean;
+    eventId: number;
+    userIdentId: number;
+    translatedSoftware?: string;
+    user?: string;
+    translatedEvent?: string;
+    date?: Date;
+    eventDescription?: string;
+    userPhotoUrl?: string;
+    icon?: string;
+}
+export interface AuditTrailDetails {
+    software: string;
+    dateTime: string;
+    userId: string;
+    userName: string;
+    userEmail: string;
+    associationId: string;
+    isMobileRequest: boolean;
+    commandIsSigned?: boolean;
+    method: string;
+    urlPath: string;
+    eventId: number;
+    eventName: string;
+    commandName: string;
+    ip: string;
+    entities: AuditTrailEntity[];
+}
+/**
+ * Tipo `AuditTrailEntity` exportado pela lib.
+ * @example
+ * const value: AuditTrailEntity = {} as AuditTrailEntity;
+ */
+export interface AuditTrailEntity {
+    id: string;
+    code: string;
+    name: string;
+    description: string;
+    item: string;
+    date: Date;
+    typeId: number;
+    typeName: string;
+    extra?: AuditTrailExtraProperty[];
+    data: AuditTrailChangedProperty[];
+    association?: AuditTrailAssociation[];
+    isElectronicSigned?: boolean;
+    status?: number;
+    statusName?: string;
+    situation?: number;
+    justification?: string;
+    equipmentType?: string;
+}
+/**
+ * Tipo `AuditTrailChangedProperty` exportado pela lib.
+ * @example
+ * const value: AuditTrailChangedProperty = {} as AuditTrailChangedProperty;
+ */
+export interface AuditTrailChangedProperty {
+    property: string;
+    propertyCustomName?: string;
+    oldValue: any;
+    newValue: any;
+    children?: AuditTrailChangedProperty[];
+    propertyResource?: string;
+    state: string;
+    tagTranslate?: string;
+    oldValueTagTranslate?: string;
+    details?: any;
+}
+/**
+ * Tipo `AuditTrailExtraProperty` exportado pela lib.
+ * @example
+ * const value: AuditTrailExtraProperty = {} as AuditTrailExtraProperty;
+ */
+export interface AuditTrailExtraProperty {
+    property: string;
+    value: string;
+    data?: any;
+    translate?: boolean;
+}
+/**
+ * Tipo `AuditTrailAssociation` exportado pela lib.
+ * @example
+ * const value: AuditTrailAssociation = {} as AuditTrailAssociation;
+ */
+export interface AuditTrailAssociation {
+    id: string;
+    code: string;
+    name: string;
+    status?: number;
+    softwareId?: number;
+    softwareName?: string;
+    type?: number | string;
+    association?: AuditTrailAssociation[];
+}
+/**
+ * Tipo `AuditTrailEvent` exportado pela lib.
+ * @example
+ * const value: AuditTrailEvent = {} as AuditTrailEvent;
+ */
+export interface AuditTrailEvent {
+    id: number;
+    name: string;
+    translation: string;
+    softwareId: number;
+}
+/**
+ * Tipo `AuditTrailSoftware` exportado pela lib.
+ * @example
+ * const value: AuditTrailSoftware = {} as AuditTrailSoftware;
+ */
+export interface AuditTrailSoftware {
+    id: number;
+    name: string;
+    software: string;
+    translation: string;
+}
+/**
+ * Tipo `AuditTrailQueryParams` exportado pela lib.
+ * @example
+ * const value: AuditTrailQueryParams = {} as AuditTrailQueryParams;
+ */
+export interface AuditTrailQueryParams {
+    software: string;
+    softwareId: number;
+    event: string;
+    eventId: number;
+    startDate: Date;
+    endDate: Date;
+    limit: number;
+    softwares: AuditTrailSoftware[];
+    userId?: string;
+    entityId?: string;
+}
+/**
+ * Tipo `AuditTrailPermissions` exportado pela lib.
+ * @example
+ * const value: AuditTrailPermissions = {} as AuditTrailPermissions;
+ */
+export interface AuditTrailPermissions {
+    viewAllEvents: boolean;
+    viewOnlyMyEvents: boolean;
+    download: boolean;
+}
+/**
+ * Tipo `AuditTrailUserOption` exportado pela lib.
+ * @example
+ * const value: AuditTrailUserOption = {} as AuditTrailUserOption;
+ */
+export interface AuditTrailUserOption {
+    id: string;
+    name: string;
+    email?: string;
+    avatar?: string;
+}
+/**
+ * Tipo `AuditTrailDetailRow` exportado pela lib.
+ * @example
+ * const value: AuditTrailDetailRow = {} as AuditTrailDetailRow;
+ */
+export interface AuditTrailDetailRow {
+    name: string;
+    value: string;
+}
+/**
+ * Tipo `AuditTrailCallbacks` exportado pela lib.
+ * @example
+ * const value: AuditTrailCallbacks = {} as AuditTrailCallbacks;
+ */
+export interface AuditTrailCallbacks {
+    /** Fetch trail list based on query params */
+    onFetchTrails: (params: AuditTrailQueryParams) => Promise<{
+        data: AuditTrail[];
+        totalRows: number;
+    }>;
+    /** Fetch events for a software */
+    onFetchEvents: (softwareId: number) => Promise<AuditTrailEvent[]>;
+    /** Fetch trail details by documentId */
+    onFetchDetails: (documentId: string) => Promise<AuditTrailDetails>;
+    /** Fetch user options for filter */
+    onFetchUsers?: () => Promise<AuditTrailUserOption[]>;
+    /** Export data (csv, pdf, xlsx) */
+    onExport?: (format: 'csv' | 'pdf' | 'xlsx', data: AuditTrail[]) => void;
+    /** Translate event name */
+    translateEvent?: (eventName: string, softwareName: string) => string;
+    /** Translate software name */
+    translateSoftware?: (softwareKey: string) => string;
+    /** Translate detail property */
+    translateProperty?: (eventName: string, propertyResource: string) => string;
+    /** Translate detail property value */
+    translatePropertyValue?: (eventName: string, propertyResource: string, value: string) => string | null;
+}

package/dist/sign/audit-trail/utils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Audit Trail Utilities
+ * Ported from Angular v1/v2 detail rendering logic
+ */
+import type { AuditTrail, AuditTrailDetails, AuditTrailDetailRow, AuditTrailEvent, AuditTrailSoftware } from './types';
+/** Process raw trails: translate software/event, compute date, sort desc *
+ * @example
+ * processTrails();
+ */
+export declare function processTrails(trails: AuditTrail[], events: AuditTrailEvent[], softwares: AuditTrailSoftware[], anonymousLabel?: string): AuditTrail[];
+export declare function translateEvent(eventName: string, events: AuditTrailEvent[]): string;
+export declare function translateSoftware(software: string, softwares: AuditTrailSoftware[]): string;
+/** Build detail rows from AuditTrailDetails (ported from v1/v2 addHeaderRow, addChangesRow, addFooterRow) *
+ * @example
+ * buildDetailRows();
+ */
+export declare function buildDetailRows(details: AuditTrailDetails, options?: {
+    translateProperty?: (eventName: string, propertyResource: string) => string;
+    translatePropertyValue?: (eventName: string, propertyResource: string, value: string) => string | null;
+    formatDate?: (date: string) => string;
+    labels?: Partial<typeof DEFAULT_LABELS>;
+}): AuditTrailDetailRow[];
+/**
+ * Função utilitária `camelToDash`.
+ * @example
+ * camelToDash();
+ */
+export declare function camelToDash(str: string): string;
+declare const DEFAULT_LABELS: {
+    readonly event: "Evento";
+    readonly entityName: "Item";
+    readonly description: string;
+    readonly justification: "Justificativa";
+    readonly status: "Status";
+    readonly type: "Tipo";
+    readonly references: string;
+    readonly security: string;
+    readonly electronicSigned: string;
+    readonly accomplishedBy: "Realizado por";
+    readonly accomplishedIn: "Realizado em";
+    readonly changedFrom: "de";
+    readonly changedTo: "para";
+    readonly uninformed: string;
+    readonly stateAdded: "(adicionado)";
+    readonly stateModified: "(modificado)";
+    readonly stateRemoved: "(removido)";
+};
+/**
+ * Tipo `AuditTrailLabels` exportado pela lib.
+ * @example
+ * const value: AuditTrailLabels = {} as AuditTrailLabels;
+ */
+export type AuditTrailLabels = Partial<typeof DEFAULT_LABELS>;
+export {};

package/dist/sign/auth/components/AliasRedirect.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Redireciona URLs legadas (sem alias) prepondo o alias ativo.
+ *
+ * Deve ser usado como catch-all (`/*`) dentro do `AliasRouteGuard`
+ * para que paths como `/okrs/26q1/1/abc` sejam redirecionados
+ * para `/{alias}/okrs/26q1/1/abc`.
+ *
+ * @example
+ * ```tsx
+ * <Route path="/*" element={<AliasRedirect />} />
+ * ```
+ */
+export declare function AliasRedirect(): import("react/jsx-runtime").JSX.Element;

package/dist/sign/auth/components/AliasRouteGuard.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface AliasRouteGuardProps {
+    children: React.ReactNode;
+    /** Nome do param de rota (default: "alias") */
+    paramName?: string;
+}
+/**
+ * Guard de rota que sincroniza o alias da URL com a sessão de autenticação.
+ *
+ * A URL é a fonte única de verdade para o alias ativo.
+ * O header/seletor de unidade apenas navega para a nova URL;
+ * este guard detecta a mudança e chama switchUnit() para sincronizar a sessão.
+ *
+ * Fluxo determinístico (1 effect):
+ * - Alias ausente na URL → redirect para /{aliasAtivo}/...
+ * - Alias inválido → redirect para /{aliasAtivo}/...
+ * - Alias válido e diferente do ativo → switchUnit(matchedCompany)
+ * - Alias correto → renderiza children
+ */
+export declare function AliasRouteGuard({ children, paramName }: AliasRouteGuardProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/auth/components/EditProfileDialog.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface EditProfileDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    user: {
+        name?: string | null;
+        email?: string | null;
+    };
+    userPhotoUrl: string | null;
+    userInitials: string;
+}
+declare const EditProfileDialog: React.FC<EditProfileDialogProps>;
+export default EditProfileDialog;

package/dist/sign/auth/components/ProtectedRoute.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface ProtectedRouteProps {
+    children: React.ReactNode;
+}
+/**
+ * Componente `ProtectedRoute` da lib.
+ * @example
+ * <ProtectedRoute />
+ */
+export declare const ProtectedRoute: React.FC<ProtectedRouteProps>;
+export {};

package/dist/sign/auth/components/UserInfo.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { Company } from '../../types';
+interface UserInfoProps {
+    variant?: 'card' | 'dropdown';
+    className?: string;
+    selectedUnit?: Company | null;
+    onUnitChange?: (unit: Company) => void;
+}
+declare const UserInfo: React.FC<UserInfoProps>;
+export default UserInfo;

package/dist/sign/auth/contexts/AuthContext.d.ts

@@ -0,0 +1,89 @@
+import React from 'react';
+import { AuthState, Company } from '../../types';
+interface AuthContextType extends AuthState {
+    logout: () => void;
+    processCallback: () => Promise<boolean>;
+    switchUnit: (company: Company) => Promise<void>;
+    availableUnits: Company[];
+    isSearchVisible: boolean;
+    setSearchVisible: (visible: boolean) => void;
+    clearSearch: () => void;
+    refreshData: () => void;
+}
+/**
+ * Componente `AuthProvider` da lib.
+ * @example
+ * <AuthProvider />
+ */
+export declare const AuthProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+/**
+ * Hook para acessar informações de autenticação e gerenciar sessão
+ *
+ * Fornece dados do usuário autenticado, empresa/unidade selecionada,
+ * e funções para logout e troca de unidade.
+ *
+ * **DEVE SER USADO DENTRO DE `<AuthProvider>`**
+ *
+ * @example
+ * ```typescript
+ * import { useAuth } from 'forlogic-core';
+ *
+ * function MyComponent() {
+ *   const {
+ *     user,              // Dados do usuário logado
+ *     alias,             // Alias da empresa/unidade ativa
+ *     companies,         // Lista de empresas disponíveis
+ *     isAuthenticated,   // true se está logado
+ *     isLoading,         // true durante inicialização
+ *     logout,            // Função para fazer logout
+ *     switchUnit         // Função para trocar de unidade
+ *   } = useAuth();
+ *
+ *   if (isLoading) return <div>Carregando...</div>;
+ *   if (!isAuthenticated) return <div>{t('not_authenticated')}</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Olá, {user?.name}</p>
+ *       <p>Empresa: {alias}</p>
+ *       <button onClick={logout}>Sair</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Trocar de unidade/empresa
+ * function UnitSelector() {
+ *   const { companies, alias, switchUnit } = useAuth();
+ *
+ *   const handleSwitch = async (company: Company) => {
+ *     await switchUnit(company);
+ *     // Cache será limpo automaticamente
+ *     // Todas as queries serão recarregadas com novo alias
+ *   };
+ *
+ *   return (
+ *     <select value={alias} onChange={(e) => {
+ *       const company = companies.find(c => c.alias === e.target.value);
+ *       if (company) handleSwitch(company);
+ *     }}>
+ *       {companies.map(c => (
+ *         <option key={c.id} value={c.alias}>{c.name}</option>
+ *       ))}
+ *     </select>
+ *   );
+ * }
+ * ```
+ *
+ * @returns Contexto de autenticação completo com user, companies, alias, etc
+ *
+ * @throws {Error} Se usado fora do AuthProvider
+ *
+ * @see {@link AuthProvider} - Provider que deve envolver a aplicação
+ */
+export declare const useAuth: () => AuthContextType;
+export {};

package/dist/sign/auth/pages/CallbackPage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Componente `CallbackPage` da lib.
+ * @example
+ * <CallbackPage />
+ */
+export declare const CallbackPage: () => import("react/jsx-runtime").JSX.Element;

package/dist/sign/auth/pages/LoginPage.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const LoginPage: React.FC;

package/dist/sign/auth/services/AuthService.d.ts

@@ -0,0 +1,45 @@
+import type { AuthState } from '../../types';
+/**
+ * Componente `AuthService` da lib.
+ * @example
+ * <AuthService />
+ */
+export declare class AuthService {
+    /**
+     * Inicializa o estado de autenticação verificando apenas tokens armazenados
+     * Tokens da URL devem ser processados exclusivamente na CallbackPage
+     */
+    static initialize(): Promise<AuthState>;
+    /**
+     * Login para ambiente de desenvolvimento - redireciona para callback com tokens
+     */
+    static loginDev(): Promise<boolean>;
+    /**
+     * Login para ambiente de produção (OAuth)
+     */
+    static loginProd(): void;
+    /**
+     * Processa o callback do OAuth (simplificado)
+     */
+    static processCallback(): Promise<boolean>;
+    /**
+     * Logout do usuário
+     */
+    static logout(): Promise<void>;
+    /**
+     * Decodifica um token JWT usando TokenService robusto
+     */
+    private static decodeToken;
+    /**
+     * Extrai informações do usuário do ID token + access token
+     */
+    private static extractUserFromIdToken;
+    /**
+     * Extrai empresas do ID token com companyId incluído
+     */
+    private static extractCompaniesFromIdToken;
+    /**
+     * Extrai alias do access token (campo default)
+     */
+    private static extractAliasFromAccessToken;
+}

package/dist/sign/auth/services/SupabaseTokenService.d.ts

@@ -0,0 +1,3 @@
+export declare class SupabaseTokenService {
+    static generateToken(accessToken: string, selectedAlias: string, onAuthFailure?: () => void, forceRegeneration?: boolean): Promise<string | null>;
+}

package/dist/sign/auth/services/TokenManager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Componente `TokenManager` da lib.
+ * @example
+ * <TokenManager />
+ */
+export declare const TokenManager: {
+    setAccessToken: (token: string) => void;
+    getAccessToken: () => string;
+    setIdToken: (token: string) => void;
+    getIdToken: () => string;
+    getSupabaseToken: () => string;
+    setOAuthState: (state: string) => void;
+    getOAuthState: () => string;
+    clearOAuthState: () => void;
+    setOAuthNonce: (nonce: string) => void;
+    getOAuthNonce: () => string;
+    clearOAuthNonce: () => void;
+    setSelectedAlias: (alias: string) => void;
+    getSelectedAlias: () => string;
+    clearSelectedAlias: () => void;
+    generateOAuthNonce: () => string;
+    hasAllTokens: () => boolean;
+    /**
+     * Detecta troca de projeto Supabase e limpa tokens stale automaticamente.
+     * Deve ser chamado ANTES de qualquer validação de token.
+     * Retorna true se houve troca (tokens foram limpos).
+     */
+    checkProjectMismatch: () => boolean;
+    setSupabaseToken: (token: string) => void;
+    areAllTokensValid: () => boolean;
+    clearExpiredTokens: () => boolean;
+    clearAll: () => void;
+    setManualLogout: () => void;
+    isManualLogout: () => boolean;
+    clearManualLogout: () => void;
+    isTokenExpired: (token: string) => boolean;
+    _validationCache: {
+        isValid: boolean;
+        timestamp: number;
+        cacheValidityMs: number;
+    };
+    _clearValidationCache: () => void;
+    isSupabaseTokenValid: () => boolean;
+    getValidSupabaseToken: () => string | null;
+    _handleExpiredToken: () => void;
+    extractTokenData: () => {
+        alias: any;
+        companyId: any;
+        placeId: any;
+        placeName: any;
+        payload: import("./TokenService").JwtPayload;
+    };
+    getCompanyId: (alias?: string) => string | null;
+    /**
+     * Retorna o ID numérico da empresa (parts[1] do campo co*).
+     * Usado exclusivamente para nomear containers Azure Blob (ex: un4104).
+     */
+    getCompanyIdInt: (alias?: string) => string | null;
+    getCurrentCompanyId: () => string | null;
+    getAllCompaniesData: () => {
+        id: string;
+        alias: string;
+        name: string;
+        payload: any;
+    }[];
+};

package/dist/sign/auth/services/TokenRegenerationService.d.ts

@@ -0,0 +1,14 @@
+export declare class TokenRegenerationService {
+    private static regenerationPromise;
+    private static onLogoutCallback;
+    /**
+     * Registra callback para ser chamado em caso de falha de autenticação
+     */
+    static setLogoutCallback(callback: () => void): void;
+    /**
+     * Tenta regenerar o token Supabase se os tokens Qualiex são válidos.
+     * Se já houver uma regeneração em andamento, aguarda a mesma promessa.
+     */
+    static attemptRegeneration(force?: boolean): Promise<string | null>;
+    private static _doRegenerate;
+}

package/dist/sign/auth/services/TokenService.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Tipo `JwtPayload` exportado pela lib.
+ * @example
+ * const value: JwtPayload = {} as JwtPayload;
+ */
+export interface JwtPayload {
+    [key: string]: any;
+    exp?: number;
+    iat?: number;
+    sub?: string;
+    iss?: string;
+}
+interface TokenValidationResult {
+    isValid: boolean;
+    idTokenValid: boolean;
+    accessTokenValid: boolean;
+    warnings: string[];
+    errors: string[];
+}
+/**
+ * Componente `TokenService` da lib.
+ * @example
+ * <TokenService />
+ */
+export declare class TokenService {
+    private static readonly LARGE_PAYLOAD_THRESHOLD;
+    /**
+     * Converte base64url para base64 padrão
+     * Resolve problema com tokens JWT que usam base64url encoding
+     */
+    private static normalizeBase64Url;
+    /**
+     * Parse JWT payload com suporte completo a base64url e múltiplas estratégias
+     * Implementa 3 estratégias de fallback para tokens grandes/problemáticos
+     */
+    static parseJwtPayload(token: string): JwtPayload | null;
+    /**
+     * Validação de tokens com diferenciação ID vs Access
+     * ID token é CRÍTICO - deve ser válido ou bloqueia login
+     * Access token é OPCIONAL - apenas warning se falhar
+     */
+    static validateTokens(accessToken: string, idToken: string): TokenValidationResult;
+    /**
+     * Verifica se um token está expirado usando validação robusta
+     */
+    static isTokenExpired(token: string): boolean;
+}
+export {};

package/dist/sign/auth/utils/ErrorInterceptor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Componente `AuthErrorInterceptor` da lib.
+ * @example
+ * <AuthErrorInterceptor />
+ */
+export declare class AuthErrorInterceptor {
+    /**
+     * Intercepts and handles authentication-related errors
+     * Returns true if error was handled and should not bubble up
+     */
+    static handleError(error: any): boolean;
+    /**
+     * Determines if an error is authentication-related
+     */
+    private static isAuthenticationError;
+    /**
+     * Wraps a promise to automatically handle authentication errors
+     */
+    static wrapAsync<T>(promise: Promise<T>): Promise<T>;
+}

package/dist/sign/components/ErrorBoundary.d.ts

@@ -0,0 +1,19 @@
+import React, { Component, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error?: Error;
+    errorInfo?: React.ErrorInfo;
+    showDetails: boolean;
+}
+export declare class ErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): Partial<State>;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    copyErrorDetails: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element;
+}
+export default ErrorBoundary;