@tantainnovative/ndpr-toolkit 3.4.0 → 3.5.0

package/dist/lawful-basis.d.ts

@@ -1,32 +1,368 @@
-import { b as LawfulBasisTrackerProps } from './LawfulBasisTracker-Cg30NbDA.js';
-export { L as LawfulBasisTracker } from './LawfulBasisTracker-Cg30NbDA.js';
-import { U as UseLawfulBasisReturn } from './useLawfulBasis-DFTmu1ca.js';
-export { u as useLawfulBasis } from './useLawfulBasis-DFTmu1ca.js';
-export { L as LawfulBasisComplianceGap, a as LawfulBasisValidationResult, b as assessComplianceGaps, g as generateLawfulBasisSummary, c as getLawfulBasisDescription, v as validateProcessingActivity } from './lawful-basis-BEyI0kGg.js';
-import { P as ProcessingActivity } from './lawful-basis-Cv1VmDLn.js';
-export { a as LawfulBasisSummary, L as LawfulBasisType, b as LegitimateInterestAssessment, S as SensitiveDataCondition } from './lawful-basis-Cv1VmDLn.js';
-import * as React from 'react';
-import React__default from 'react';
-import { S as StorageAdapter } from './types-DK2CoKOC.js';
-
-interface LawfulBasisProviderProps {
-    adapter?: StorageAdapter<ProcessingActivity[]>;
-    storageKey?: string;
-    useLocalStorage?: boolean;
-    initialActivities?: ProcessingActivity[];
-    onAdd?: (activity: ProcessingActivity) => void;
-    onUpdate?: (activity: ProcessingActivity) => void;
-    onRemove?: (id: string) => void;
-    children: React__default.ReactNode;
-}
-declare const LawfulBasisProvider: React__default.FC<LawfulBasisProviderProps>;
-
-declare const LawfulBasis: {
-    Provider: React.FC<LawfulBasisProviderProps>;
-    Tracker: React.FC<LawfulBasisTrackerProps>;
-};
-
-type LawfulBasisContextValue = UseLawfulBasisReturn;
-declare function useLawfulBasisCompound(): LawfulBasisContextValue;
-
-export { LawfulBasis, LawfulBasisProvider, type LawfulBasisProviderProps, ProcessingActivity, StorageAdapter, UseLawfulBasisReturn, useLawfulBasisCompound };
+import * as React_2 from 'react';
+import React__default from 'react';
+
+/**
+ * Analyzes all processing activities and returns compliance gaps including
+ * missing DPO approval, overdue reviews, undocumented justifications,
+ * missing LIA for legitimate interests, and other documentation issues.
+ *
+ * @param activities Array of processing activities to analyze
+ * @returns Array of identified compliance gaps
+ */
+export declare function assessComplianceGaps(activities: ProcessingActivity[]): LawfulBasisComplianceGap[];
+
+/**
+ * Generates a summary of all lawful basis documentation across processing activities.
+ *
+ * @param activities Array of processing activities to summarize
+ * @returns LawfulBasisSummary with counts, breakdowns, and flagged activities
+ */
+export declare function generateLawfulBasisSummary(activities: ProcessingActivity[]): LawfulBasisSummary;
+
+/**
+ * Returns a human-readable description of a lawful basis with the relevant
+ * NDPA section reference.
+ *
+ * @param basis The lawful basis to describe
+ * @returns Description string including NDPA section reference
+ */
+export declare function getLawfulBasisDescription(basis: LawfulBasisType): string;
+
+export declare const LawfulBasis: {
+    Provider: React_2.FC<LawfulBasisProviderProps>;
+    Tracker: React_2.FC<LawfulBasisTrackerProps>;
+};
+
+/**
+ * Compliance gap identified across processing activities
+ */
+export declare interface LawfulBasisComplianceGap {
+    activityId: string;
+    activityName: string;
+    type: 'missing_approval' | 'overdue_review' | 'missing_justification' | 'missing_lia' | 'missing_sensitive_condition' | 'missing_retention' | 'missing_data_categories' | 'missing_purposes';
+    severity: 'high' | 'medium' | 'low';
+    description: string;
+}
+
+declare type LawfulBasisContextValue = UseLawfulBasisReturn;
+
+export declare const LawfulBasisProvider: React__default.FC<LawfulBasisProviderProps>;
+
+export declare interface LawfulBasisProviderProps {
+    adapter?: StorageAdapter<ProcessingActivity[]>;
+    storageKey?: string;
+    useLocalStorage?: boolean;
+    initialActivities?: ProcessingActivity[];
+    onAdd?: (activity: ProcessingActivity) => void;
+    onUpdate?: (activity: ProcessingActivity) => void;
+    onRemove?: (id: string) => void;
+    children: React__default.ReactNode;
+}
+
+/**
+ * Summary of all lawful basis documentation for compliance reporting
+ */
+export declare interface LawfulBasisSummary {
+    /** Total number of processing activities */
+    totalActivities: number;
+    /** Breakdown by lawful basis */
+    byBasis: Record<LawfulBasisType, number>;
+    /** Number of activities involving sensitive data */
+    sensitiveDataActivities: number;
+    /** Number of activities involving cross-border transfers */
+    crossBorderActivities: number;
+    /** Activities due for review */
+    activitiesDueForReview: ProcessingActivity[];
+    /** Activities without DPO approval */
+    activitiesWithoutApproval: ProcessingActivity[];
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+
+/**
+ * Lawful basis tracker component. Implements NDPA Section 25 requirements for documenting
+ * and tracking the lawful basis for each personal data processing activity.
+ */
+export declare const LawfulBasisTracker: React__default.FC<LawfulBasisTrackerProps>;
+
+declare interface LawfulBasisTrackerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    summary?: string;
+    summaryCard?: string;
+    table?: string;
+    tableHeader?: string;
+    tableRow?: string;
+    form?: string;
+    input?: string;
+    select?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    statusBadge?: string;
+    complianceScore?: string;
+    gapAlert?: string;
+}
+
+declare interface LawfulBasisTrackerProps {
+    /**
+     * List of processing activities to display
+     */
+    activities: ProcessingActivity[];
+    /**
+     * Callback when a new activity is created
+     */
+    onAddActivity?: (activity: Omit<ProcessingActivity, 'id' | 'createdAt' | 'updatedAt'>) => void;
+    /**
+     * Callback when an activity is updated
+     */
+    onUpdateActivity?: (id: string, updates: Partial<ProcessingActivity>) => void;
+    /**
+     * Callback when an activity is archived
+     */
+    onArchiveActivity?: (id: string) => void;
+    /**
+     * Title displayed on the tracker
+     * @default "Lawful Basis Tracker"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the tracker
+     * @default "Document and track the lawful basis for each processing activity as required by NDPA 2023 Section 25."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the tracker container
+     */
+    className?: string;
+    /**
+     * Custom CSS class for buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the compliance summary at the top
+     * @default true
+     */
+    showSummary?: boolean;
+    /**
+     * Whether to show compliance gap alerts
+     * @default true
+     */
+    showComplianceGaps?: boolean;
+    /**
+     * Override class names for individual sections of the component.
+     * Takes priority over className / buttonClassName.
+     */
+    classNames?: LawfulBasisTrackerClassNames;
+    /**
+     * When true, all default styling is removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Lawful Basis types aligned with NDPA 2023 Part III (Sections 24-28)
+ * Every processing activity must have a documented lawful basis
+ */
+/**
+ * The six lawful bases for processing personal data per NDPA Section 25(1)
+ */
+export declare type LawfulBasisType = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+/**
+ * Validation result for a processing activity
+ */
+export declare interface LawfulBasisValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/**
+ * Represents a Legitimate Interest Assessment (LIA)
+ * Required when the lawful basis is 'legitimate_interests'
+ */
+export declare interface LegitimateInterestAssessment {
+    /** Unique identifier */
+    id: string;
+    /** ID of the associated processing activity */
+    processingActivityId: string;
+    /** Date the assessment was conducted */
+    assessmentDate: number;
+    /** Person who conducted the assessment */
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    /** Description of the legitimate interest being pursued */
+    purposeTest: string;
+    /** Why the processing is necessary for this purpose */
+    necessityTest: string;
+    /** Balancing test: rights of data subject vs. legitimate interest */
+    balancingTest: string;
+    /** Safeguards applied to protect data subject rights */
+    safeguards: string[];
+    /** Overall conclusion */
+    conclusion: string;
+    /** Whether the assessment concluded the processing is justified */
+    approved: boolean;
+}
+
+/**
+ * Represents a processing activity and its lawful basis
+ */
+export declare interface ProcessingActivity {
+    /** Unique identifier */
+    id: string;
+    /** Name of the processing activity */
+    name: string;
+    /** Description of what processing is performed */
+    description: string;
+    /** The lawful basis for this processing activity */
+    lawfulBasis: LawfulBasisType;
+    /** Justification for why this lawful basis applies */
+    lawfulBasisJustification: string;
+    /** Categories of personal data being processed */
+    dataCategories: string[];
+    /** Whether sensitive personal data is involved */
+    involvesSensitiveData: boolean;
+    /** Condition for processing sensitive data (required if involvesSensitiveData is true) */
+    sensitiveDataCondition?: SensitiveDataCondition;
+    /** Categories of data subjects */
+    dataSubjectCategories: string[];
+    /** Purposes of the processing */
+    purposes: string[];
+    /** Data retention period */
+    retentionPeriod: string;
+    /** Justification for the retention period */
+    retentionJustification?: string;
+    /** Recipients or categories of recipients */
+    recipients?: string[];
+    /** Whether data is transferred outside Nigeria */
+    crossBorderTransfer: boolean;
+    /** Timestamp when the record was created */
+    createdAt: number;
+    /** Timestamp when the record was last updated */
+    updatedAt: number;
+    /** Next review date */
+    reviewDate?: number;
+    /** Status of the processing activity */
+    status: 'active' | 'inactive' | 'under_review' | 'archived';
+    /** DPO approval details */
+    dpoApproval?: {
+        approved: boolean;
+        approvedBy: string;
+        approvedAt: number;
+        notes?: string;
+    };
+}
+
+/**
+ * Additional conditions required for processing sensitive personal data
+ * per NDPA Section 27
+ */
+export declare type SensitiveDataCondition = 'explicit_consent' | 'employment_law' | 'vital_interests_incapable' | 'nonprofit_legitimate' | 'publicly_available' | 'legal_claims' | 'substantial_public_interest' | 'health_purposes' | 'public_health' | 'archiving_research';
+
+export declare interface StorageAdapter<T = unknown> {
+    /** Load persisted data. Called once on hook mount. */
+    load(): T | null | Promise<T | null>;
+    /** Persist data. Called on every state change. */
+    save(data: T): void | Promise<void>;
+    /** Clear persisted data. Called on reset. */
+    remove(): void | Promise<void>;
+}
+
+/**
+ * Hook for managing lawful basis documentation for processing activities
+ * in compliance with NDPA 2023 Section 25.
+ */
+export declare function useLawfulBasis({ initialActivities, adapter, storageKey, useLocalStorage, onAdd, onUpdate, onRemove, }?: UseLawfulBasisOptions): UseLawfulBasisReturn;
+
+export declare function useLawfulBasisCompound(): LawfulBasisContextValue;
+
+declare interface UseLawfulBasisOptions {
+    /**
+     * Initial processing activities to load
+     */
+    initialActivities?: ProcessingActivity[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<ProcessingActivity[]>;
+    /**
+     * Storage key for persisting activities
+     * @default "ndpr_lawful_basis_activities"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist activities
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback when an activity is added
+     */
+    onAdd?: (activity: ProcessingActivity) => void;
+    /**
+     * Callback when an activity is updated
+     */
+    onUpdate?: (activity: ProcessingActivity) => void;
+    /**
+     * Callback when an activity is removed
+     */
+    onRemove?: (id: string) => void;
+}
+
+export declare interface UseLawfulBasisReturn {
+    /**
+     * All processing activities
+     */
+    activities: ProcessingActivity[];
+    /**
+     * Add a new processing activity
+     */
+    addActivity: (activity: Omit<ProcessingActivity, 'id' | 'createdAt' | 'updatedAt'>) => ProcessingActivity;
+    /**
+     * Update an existing processing activity
+     */
+    updateActivity: (id: string, updates: Partial<ProcessingActivity>) => ProcessingActivity | null;
+    /**
+     * Remove a processing activity
+     */
+    removeActivity: (id: string) => void;
+    /**
+     * Get a specific processing activity by ID
+     */
+    getActivity: (id: string) => ProcessingActivity | null;
+    /**
+     * Get a summary of all lawful basis documentation
+     */
+    getSummary: () => LawfulBasisSummary;
+    /**
+     * Validate a processing activity
+     */
+    validateActivity: (activity: ProcessingActivity) => LawfulBasisValidationResult;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Validates that all required fields are present on a processing activity
+ * and that the lawful basis is properly documented.
+ *
+ * If lawfulBasis is 'legitimate_interests', ensures a LIA justification exists.
+ * If involvesSensitiveData is true, ensures sensitiveDataCondition is set.
+ *
+ * @param activity The processing activity to validate
+ * @returns Validation result with errors and warnings
+ */
+export declare function validateProcessingActivity(activity: ProcessingActivity): LawfulBasisValidationResult;
+
+export { }

package/dist/lawful-basis.js

@@ -1,2 +1,3 @@
+"use client";
 'use strict';var chunkLSNL4XR5_js=require('./chunk-LSNL4XR5.js'),chunk7AVN424U_js=require('./chunk-7AVN424U.js'),chunkTDDAYVKK_js=require('./chunk-TDDAYVKK.js');require('./chunk-E64TU6IU.js'),require('./chunk-ELKB2AFZ.js'),require('./chunk-MQFZHA2D.js');var react=require('react'),jsxRuntime=require('react/jsx-runtime');var r=react.createContext(null);function x(){let s=react.useContext(r);if(!s)throw new Error("LawfulBasis compound components must be wrapped in <LawfulBasis.Provider>. Example: <LawfulBasis.Provider><LawfulBasis.Tracker /></LawfulBasis.Provider>");return s}var e=({adapter:s,storageKey:t,useLocalStorage:i,initialActivities:u,onAdd:f,onUpdate:p,onRemove:l,children:n})=>{let m=chunk7AVN424U_js.a({adapter:s,storageKey:t,useLocalStorage:i,initialActivities:u,onAdd:f,onUpdate:p,onRemove:l});return jsxRuntime.jsx(r.Provider,{value:m,children:n})};var y={Provider:e,Tracker:chunkLSNL4XR5_js.a};Object.defineProperty(exports,"LawfulBasisTracker",{enumerable:true,get:function(){return chunkLSNL4XR5_js.a}});Object.defineProperty(exports,"useLawfulBasis",{enumerable:true,get:function(){return chunk7AVN424U_js.a}});Object.defineProperty(exports,"assessComplianceGaps",{enumerable:true,get:function(){return chunkTDDAYVKK_js.c}});Object.defineProperty(exports,"generateLawfulBasisSummary",{enumerable:true,get:function(){return chunkTDDAYVKK_js.d}});Object.defineProperty(exports,"getLawfulBasisDescription",{enumerable:true,get:function(){return chunkTDDAYVKK_js.b}});Object.defineProperty(exports,"validateProcessingActivity",{enumerable:true,get:function(){return chunkTDDAYVKK_js.a}});exports.LawfulBasis=y;exports.LawfulBasisProvider=e;exports.useLawfulBasisCompound=x;//# sourceMappingURL=lawful-basis.js.map
 //# sourceMappingURL=lawful-basis.js.map

package/dist/lawful-basis.mjs

@@ -1,2 +1,3 @@
+"use client";
 import {a}from'./chunk-CISJAQ6W.mjs';export{a as LawfulBasisTracker}from'./chunk-CISJAQ6W.mjs';import {a as a$1}from'./chunk-E4NCJ7RD.mjs';export{a as useLawfulBasis}from'./chunk-E4NCJ7RD.mjs';export{c as assessComplianceGaps,d as generateLawfulBasisSummary,b as getLawfulBasisDescription,a as validateProcessingActivity}from'./chunk-TXBZPCGF.mjs';import'./chunk-AYKLAEOU.mjs';import'./chunk-6WIP33TW.mjs';import'./chunk-WWT2ZSNU.mjs';import {createContext,useContext}from'react';import {jsx}from'react/jsx-runtime';var r=createContext(null);function x(){let s=useContext(r);if(!s)throw new Error("LawfulBasis compound components must be wrapped in <LawfulBasis.Provider>. Example: <LawfulBasis.Provider><LawfulBasis.Tracker /></LawfulBasis.Provider>");return s}var e=({adapter:s,storageKey:t,useLocalStorage:i,initialActivities:u,onAdd:f,onUpdate:p,onRemove:l,children:n})=>{let m=a$1({adapter:s,storageKey:t,useLocalStorage:i,initialActivities:u,onAdd:f,onUpdate:p,onRemove:l});return jsx(r.Provider,{value:m,children:n})};var y={Provider:e,Tracker:a};export{y as LawfulBasis,e as LawfulBasisProvider,x as useLawfulBasisCompound};//# sourceMappingURL=lawful-basis.mjs.map
 //# sourceMappingURL=lawful-basis.mjs.map