@tantainnovative/ndpr-toolkit 3.4.0 → 3.5.0

package/dist/ropa.d.ts

@@ -1,31 +1,396 @@
-import { b as ROPAManagerProps } from './ROPAManager-qxTrXLkD.js';
-export { R as ROPAManager } from './ROPAManager-qxTrXLkD.js';
-import { a as UseROPAReturn } from './useROPA-BSSU1rfx.js';
-export { U as UseROPAOptions, u as useROPA } from './useROPA-BSSU1rfx.js';
-export { R as ROPAComplianceGap, a as ROPAValidationResult, e as exportROPAToCSV, g as generateROPASummary, i as identifyComplianceGaps, v as validateProcessingRecord } from './ropa-CyynscU6.js';
-import { a as RecordOfProcessingActivities, P as ProcessingRecord } from './ropa-BDTM06tr.js';
-export { R as ROPASummary } from './ropa-BDTM06tr.js';
-import * as React from 'react';
-import React__default from 'react';
-import { S as StorageAdapter } from './types-DK2CoKOC.js';
-import './lawful-basis-Cv1VmDLn.js';
-
-interface ROPAProviderProps {
-    initialData: RecordOfProcessingActivities;
-    adapter?: StorageAdapter<RecordOfProcessingActivities>;
-    onRecordAdd?: (record: ProcessingRecord) => void;
-    onRecordUpdate?: (id: string, updates: Partial<ProcessingRecord>) => void;
-    onRecordArchive?: (id: string) => void;
-    children: React__default.ReactNode;
-}
-declare const ROPAProvider: React__default.FC<ROPAProviderProps>;
-
-declare const ROPA: {
-    Provider: React.FC<ROPAProviderProps>;
-    Manager: React.FC<ROPAManagerProps>;
-};
-
-type ROPAContextValue = UseROPAReturn;
-declare function useROPACompound(): ROPAContextValue;
-
-export { ProcessingRecord, ROPA, ROPAProvider, type ROPAProviderProps, RecordOfProcessingActivities, StorageAdapter, UseROPAReturn, useROPACompound };
+import * as React_2 from 'react';
+import React__default from 'react';
+
+/**
+ * Exports the Record of Processing Activities to a CSV string.
+ * The CSV includes all key fields from each processing record.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns CSV-formatted string
+ */
+export declare function exportROPAToCSV(ropa: RecordOfProcessingActivities): string;
+
+/**
+ * Generates a summary of the Record of Processing Activities.
+ * Provides statistics and identifies records that are due for review.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns Summary statistics for the ROPA
+ */
+export declare function generateROPASummary(ropa: RecordOfProcessingActivities): ROPASummary;
+
+/**
+ * Identifies compliance gaps in the Record of Processing Activities.
+ * Finds records that are missing required information per NDPA 2023.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns Array of compliance gaps grouped by record
+ */
+export declare function identifyComplianceGaps(ropa: RecordOfProcessingActivities): ROPAComplianceGap[];
+
+/**
+ * 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)
+ */
+declare type LawfulBasis = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+/**
+ * Record of Processing Activities (ROPA) types aligned with NDPA 2023
+ * Data controllers must maintain comprehensive records of all processing activities
+ */
+
+/**
+ * Represents a single processing record in the ROPA
+ */
+export declare interface ProcessingRecord {
+    /** Unique identifier */
+    id: string;
+    /** Name of the processing activity */
+    name: string;
+    /** Detailed description of the processing */
+    description: string;
+    /** Data controller details */
+    controllerDetails: {
+        name: string;
+        contact: string;
+        address: string;
+        registrationNumber?: string;
+        dpoContact?: string;
+    };
+    /** Joint controller details (if applicable) */
+    jointControllerDetails?: {
+        name: string;
+        contact: string;
+        address: string;
+        responsibilities: string;
+    };
+    /** Data processor details (if processing is outsourced) */
+    processorDetails?: {
+        name: string;
+        contact: string;
+        address: string;
+        contractReference?: string;
+    };
+    /** Lawful basis for the processing */
+    lawfulBasis: LawfulBasis;
+    /** Justification for the chosen lawful basis */
+    lawfulBasisJustification: string;
+    /** Purposes of the processing */
+    purposes: string[];
+    /** Categories of personal data processed */
+    dataCategories: string[];
+    /** Categories of sensitive personal data (if any) */
+    sensitiveDataCategories?: string[];
+    /** Categories of data subjects */
+    dataSubjectCategories: string[];
+    /** Recipients or categories of recipients */
+    recipients: string[];
+    /** Cross-border transfer details */
+    crossBorderTransfers?: Array<{
+        destinationCountry: string;
+        countryCode?: string;
+        safeguards: string;
+        transferMechanism: string;
+    }>;
+    /** Data retention period */
+    retentionPeriod: string;
+    /** Justification for the retention period */
+    retentionJustification?: string;
+    /** Technical and organizational security measures */
+    securityMeasures: string[];
+    /** Data source (directly from data subject or from third party) */
+    dataSource: 'data_subject' | 'third_party' | 'public_source' | 'other';
+    /** Third-party source details (if dataSource is 'third_party') */
+    thirdPartySourceDetails?: string;
+    /** Whether a DPIA is required for this processing */
+    dpiaRequired: boolean;
+    /** Reference to the DPIA (if conducted) */
+    dpiaReference?: string;
+    /** Whether automated decision-making is involved */
+    automatedDecisionMaking: boolean;
+    /** Details of automated decision-making (if applicable) */
+    automatedDecisionMakingDetails?: string;
+    /** Status of the processing record */
+    status: 'active' | 'inactive' | 'archived';
+    /** Department or business unit responsible */
+    department?: string;
+    /** System or application used for processing */
+    systemsUsed?: string[];
+    /** Timestamp when the record was created */
+    createdAt: number;
+    /** Timestamp when the record was last updated */
+    updatedAt: number;
+    /** Timestamp when the record was last reviewed */
+    lastReviewedAt?: number;
+    /** Next review date */
+    nextReviewDate?: number;
+}
+
+/**
+ * Represents a complete Record of Processing Activities
+ */
+export declare interface RecordOfProcessingActivities {
+    /** Unique identifier */
+    id: string;
+    /** Organization name */
+    organizationName: string;
+    /** Organization contact information */
+    organizationContact: string;
+    /** Organization address */
+    organizationAddress: string;
+    /** Data Protection Officer details */
+    dpoDetails?: {
+        name: string;
+        email: string;
+        phone?: string;
+    };
+    /** NDPC registration number */
+    ndpcRegistrationNumber?: string;
+    /** All processing records */
+    records: ProcessingRecord[];
+    /** Timestamp when the ROPA was last updated */
+    lastUpdated: number;
+    /** Version of the ROPA */
+    version: string;
+    /** Export format options */
+    exportFormats?: ('pdf' | 'csv' | 'json' | 'xlsx')[];
+}
+
+export declare const ROPA: {
+    Provider: React_2.FC<ROPAProviderProps>;
+    Manager: React_2.FC<ROPAManagerProps>;
+};
+
+/**
+ * Compliance gap found in a processing record
+ */
+export declare interface ROPAComplianceGap {
+    recordId: string;
+    recordName: string;
+    gaps: string[];
+}
+
+declare type ROPAContextValue = UseROPAReturn;
+
+/**
+ * Record of Processing Activities (ROPA) management component. Implements the NDPA
+ * accountability principle, requiring organizations to maintain comprehensive records
+ * of all personal data processing activities.
+ */
+export declare const ROPAManager: React__default.FC<ROPAManagerProps>;
+
+declare interface ROPAManagerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    orgInfo?: 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;
+    exportButton?: string;
+    /** Alias for exportButton */
+    secondaryButton?: string;
+    complianceGap?: string;
+}
+
+declare interface ROPAManagerProps {
+    /**
+     * The full Record of Processing Activities
+     */
+    ropa: RecordOfProcessingActivities;
+    /**
+     * Callback when a new record is added
+     */
+    onAddRecord?: (record: ProcessingRecord) => void;
+    /**
+     * Callback when a record is updated
+     */
+    onUpdateRecord?: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Callback when a record is archived
+     */
+    onArchiveRecord?: (id: string) => void;
+    /**
+     * Title displayed on the manager
+     * @default "Record of Processing Activities (ROPA)"
+     */
+    title?: string;
+    /**
+     * Description text
+     * @default "Maintain a comprehensive record of all data processing activities as required by the NDPA accountability principle."
+     */
+    description?: string;
+    /**
+     * Custom CSS class
+     */
+    className?: string;
+    /**
+     * Custom CSS class for buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual sections of the component.
+     * Takes priority over className / buttonClassName.
+     */
+    classNames?: ROPAManagerClassNames;
+    /**
+     * When true, all default styling is removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+export declare const ROPAProvider: React__default.FC<ROPAProviderProps>;
+
+export declare interface ROPAProviderProps {
+    initialData: RecordOfProcessingActivities;
+    adapter?: StorageAdapter<RecordOfProcessingActivities>;
+    onRecordAdd?: (record: ProcessingRecord) => void;
+    onRecordUpdate?: (id: string, updates: Partial<ProcessingRecord>) => void;
+    onRecordArchive?: (id: string) => void;
+    children: React__default.ReactNode;
+}
+
+/**
+ * Summary statistics for the ROPA
+ */
+export declare interface ROPASummary {
+    /** Total number of processing records */
+    totalRecords: number;
+    /** Active processing records */
+    activeRecords: number;
+    /** Records by lawful basis */
+    byLawfulBasis: Record<LawfulBasis, number>;
+    /** Records involving sensitive data */
+    sensitiveDataRecords: number;
+    /** Records involving cross-border transfers */
+    crossBorderRecords: number;
+    /** Records requiring DPIA */
+    dpiaRequiredRecords: number;
+    /** Records involving automated decision-making */
+    automatedDecisionRecords: number;
+    /** Records due for review */
+    recordsDueForReview: ProcessingRecord[];
+    /** Departments with most processing activities */
+    topDepartments: Array<{
+        department: string;
+        count: number;
+    }>;
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+
+/**
+ * Validation result for a processing record
+ */
+export declare interface ROPAValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+
+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 a Record of Processing Activities (ROPA)
+ * in compliance with NDPA 2023 requirements.
+ *
+ * Provides state management and utility functions for maintaining
+ * a comprehensive register of all data processing activities.
+ */
+export declare function useROPA({ initialData, adapter, onRecordAdd, onRecordUpdate, onRecordArchive, }: UseROPAOptions): UseROPAReturn;
+
+export declare function useROPACompound(): ROPAContextValue;
+
+export declare interface UseROPAOptions {
+    /**
+     * Initial ROPA state
+     */
+    initialData: RecordOfProcessingActivities;
+    /**
+     * Pluggable storage adapter. When provided, adapter data is loaded on mount
+     * and the ROPA is persisted after every mutation. Falls back to initialData
+     * when no adapter data is found.
+     */
+    adapter?: StorageAdapter<RecordOfProcessingActivities>;
+    /**
+     * Callback when a record is added
+     */
+    onRecordAdd?: (record: ProcessingRecord) => void;
+    /**
+     * Callback when a record is updated
+     */
+    onRecordUpdate?: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Callback when a record is archived
+     */
+    onRecordArchive?: (id: string) => void;
+}
+
+export declare interface UseROPAReturn {
+    /**
+     * Current state of the Record of Processing Activities
+     */
+    ropa: RecordOfProcessingActivities;
+    /**
+     * Add a new processing record
+     */
+    addRecord: (record: ProcessingRecord) => void;
+    /**
+     * Update an existing processing record
+     */
+    updateRecord: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Archive a processing record by setting its status to 'archived'
+     */
+    archiveRecord: (id: string) => void;
+    /**
+     * Get a single processing record by ID
+     */
+    getRecord: (id: string) => ProcessingRecord | undefined;
+    /**
+     * Get a summary of the ROPA including statistics
+     */
+    getSummary: () => ROPASummary;
+    /**
+     * Export the ROPA as a CSV string
+     */
+    exportCSV: () => string;
+    /**
+     * Identify compliance gaps across all records
+     */
+    getComplianceGaps: () => ROPAComplianceGap[];
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Validates a processing record to ensure all required fields are present
+ * and properly filled per NDPA 2023 requirements.
+ *
+ * @param record - The processing record to validate
+ * @returns Validation result with any errors found
+ */
+export declare function validateProcessingRecord(record: ProcessingRecord): ROPAValidationResult;
+
+export { }

package/dist/ropa.js

@@ -1,2 +1,3 @@
-'use strict';var chunkP6QAFBCV_js=require('./chunk-P6QAFBCV.js'),chunkM2TPT5GB_js=require('./chunk-M2TPT5GB.js'),chunkGOU6FU6Y_js=require('./chunk-GOU6FU6Y.js');require('./chunk-E64TU6IU.js'),require('./chunk-MQFZHA2D.js');var react=require('react'),jsxRuntime=require('react/jsx-runtime');var p=react.createContext(null);function u(){let r=react.useContext(p);if(!r)throw new Error("ROPA compound components must be wrapped in <ROPA.Provider>. Example: <ROPA.Provider initialData={...}><ROPA.Manager /></ROPA.Provider>");return r}var e=({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a,children:s})=>{let R=chunkM2TPT5GB_js.a({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a});return jsxRuntime.jsx(p.Provider,{value:R,children:s})};var v={Provider:e,Manager:chunkP6QAFBCV_js.a};Object.defineProperty(exports,"ROPAManager",{enumerable:true,get:function(){return chunkP6QAFBCV_js.a}});Object.defineProperty(exports,"useROPA",{enumerable:true,get:function(){return chunkM2TPT5GB_js.a}});Object.defineProperty(exports,"exportROPAToCSV",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.c}});Object.defineProperty(exports,"generateROPASummary",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.b}});Object.defineProperty(exports,"identifyComplianceGaps",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.d}});Object.defineProperty(exports,"validateProcessingRecord",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.a}});exports.ROPA=v;exports.ROPAProvider=e;exports.useROPACompound=u;//# sourceMappingURL=ropa.js.map
+"use client";
+'use strict';var chunkXNSZ7KUH_js=require('./chunk-XNSZ7KUH.js'),chunkM2TPT5GB_js=require('./chunk-M2TPT5GB.js'),chunkGOU6FU6Y_js=require('./chunk-GOU6FU6Y.js');require('./chunk-E64TU6IU.js'),require('./chunk-MQFZHA2D.js');var react=require('react'),jsxRuntime=require('react/jsx-runtime');var p=react.createContext(null);function u(){let r=react.useContext(p);if(!r)throw new Error("ROPA compound components must be wrapped in <ROPA.Provider>. Example: <ROPA.Provider initialData={...}><ROPA.Manager /></ROPA.Provider>");return r}var e=({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a,children:s})=>{let R=chunkM2TPT5GB_js.a({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a});return jsxRuntime.jsx(p.Provider,{value:R,children:s})};var v={Provider:e,Manager:chunkXNSZ7KUH_js.a};Object.defineProperty(exports,"ROPAManager",{enumerable:true,get:function(){return chunkXNSZ7KUH_js.a}});Object.defineProperty(exports,"useROPA",{enumerable:true,get:function(){return chunkM2TPT5GB_js.a}});Object.defineProperty(exports,"exportROPAToCSV",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.c}});Object.defineProperty(exports,"generateROPASummary",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.b}});Object.defineProperty(exports,"identifyComplianceGaps",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.d}});Object.defineProperty(exports,"validateProcessingRecord",{enumerable:true,get:function(){return chunkGOU6FU6Y_js.a}});exports.ROPA=v;exports.ROPAProvider=e;exports.useROPACompound=u;//# sourceMappingURL=ropa.js.map
 //# sourceMappingURL=ropa.js.map

package/dist/ropa.mjs

@@ -1,2 +1,3 @@
-import {a}from'./chunk-VTITKWGX.mjs';export{a as ROPAManager}from'./chunk-VTITKWGX.mjs';import {a as a$1}from'./chunk-2AW7KAZO.mjs';export{a as useROPA}from'./chunk-2AW7KAZO.mjs';export{c as exportROPAToCSV,b as generateROPASummary,d as identifyComplianceGaps,a as validateProcessingRecord}from'./chunk-SHMJNRHO.mjs';import'./chunk-AYKLAEOU.mjs';import'./chunk-WWT2ZSNU.mjs';import {createContext,useContext}from'react';import {jsx}from'react/jsx-runtime';var p=createContext(null);function u(){let r=useContext(p);if(!r)throw new Error("ROPA compound components must be wrapped in <ROPA.Provider>. Example: <ROPA.Provider initialData={...}><ROPA.Manager /></ROPA.Provider>");return r}var e=({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a,children:s})=>{let R=a$1({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a});return jsx(p.Provider,{value:R,children:s})};var v={Provider:e,Manager:a};export{v as ROPA,e as ROPAProvider,u as useROPACompound};//# sourceMappingURL=ropa.mjs.map
+"use client";
+import {a}from'./chunk-QSVVAZVT.mjs';export{a as ROPAManager}from'./chunk-QSVVAZVT.mjs';import {a as a$1}from'./chunk-2AW7KAZO.mjs';export{a as useROPA}from'./chunk-2AW7KAZO.mjs';export{c as exportROPAToCSV,b as generateROPASummary,d as identifyComplianceGaps,a as validateProcessingRecord}from'./chunk-SHMJNRHO.mjs';import'./chunk-AYKLAEOU.mjs';import'./chunk-WWT2ZSNU.mjs';import {createContext,useContext}from'react';import {jsx}from'react/jsx-runtime';var p=createContext(null);function u(){let r=useContext(p);if(!r)throw new Error("ROPA compound components must be wrapped in <ROPA.Provider>. Example: <ROPA.Provider initialData={...}><ROPA.Manager /></ROPA.Provider>");return r}var e=({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a,children:s})=>{let R=a$1({initialData:r,adapter:i,onRecordAdd:P,onRecordUpdate:n,onRecordArchive:a});return jsx(p.Provider,{value:R,children:s})};var v={Provider:e,Manager:a};export{v as ROPA,e as ROPAProvider,u as useROPACompound};//# sourceMappingURL=ropa.mjs.map
 //# sourceMappingURL=ropa.mjs.map