@tantainnovative/ndpr-toolkit 1.0.0

package/dist/components/policy/PolicyPreview.d.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import { PolicySection, PolicyVariable } from '../../types/privacy';
+export interface PolicyPreviewProps {
+    /**
+     * The policy content to preview
+     */
+    content: string;
+    /**
+     * The policy sections
+     */
+    sections?: PolicySection[];
+    /**
+     * The policy variables
+     */
+    variables?: PolicyVariable[];
+    /**
+     * Callback function called when the policy is exported
+     */
+    onExport?: (format: 'pdf' | 'html' | 'markdown' | 'docx') => void;
+    /**
+     * Callback function called when the policy is edited
+     */
+    onEdit?: () => void;
+    /**
+     * Title displayed on the preview
+     * @default "Privacy Policy Preview"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the preview
+     * @default "Preview your NDPR-compliant privacy policy before exporting."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the preview
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the export options
+     * @default true
+     */
+    showExportOptions?: boolean;
+    /**
+     * Whether to show the edit button
+     * @default true
+     */
+    showEditButton?: boolean;
+    /**
+     * Whether to show the table of contents
+     * @default true
+     */
+    showTableOfContents?: boolean;
+    /**
+     * Whether to show the policy metadata
+     * @default true
+     */
+    showMetadata?: boolean;
+    /**
+     * The organization name to display in the policy
+     */
+    organizationName?: string;
+    /**
+     * The last updated date to display in the policy
+     */
+    lastUpdated?: Date;
+}
+export declare const PolicyPreview: React.FC<PolicyPreviewProps>;

package/dist/hooks/useBreach.d.ts

@@ -0,0 +1,97 @@
+import { BreachReport, BreachCategory, RiskAssessment, NotificationRequirement, RegulatoryNotification } from '../types/breach';
+interface UseBreachOptions {
+    /**
+     * Available breach categories
+     */
+    categories: BreachCategory[];
+    /**
+     * Initial breach reports
+     */
+    initialReports?: BreachReport[];
+    /**
+     * Storage key for breach data
+     * @default "ndpr_breach_data"
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist breach data
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a breach is reported
+     */
+    onReport?: (report: BreachReport) => void;
+    /**
+     * Callback function called when a risk assessment is completed
+     */
+    onAssessment?: (assessment: RiskAssessment) => void;
+    /**
+     * Callback function called when a notification is sent
+     */
+    onNotification?: (notification: RegulatoryNotification) => void;
+}
+interface UseBreachReturn {
+    /**
+     * All breach reports
+     */
+    reports: BreachReport[];
+    /**
+     * All risk assessments
+     */
+    assessments: RiskAssessment[];
+    /**
+     * All regulatory notifications
+     */
+    notifications: RegulatoryNotification[];
+    /**
+     * Submit a new breach report
+     */
+    reportBreach: (reportData: Omit<BreachReport, 'id' | 'reportedAt'>) => BreachReport;
+    /**
+     * Update an existing breach report
+     */
+    updateReport: (id: string, updates: Partial<BreachReport>) => BreachReport | null;
+    /**
+     * Get a breach report by ID
+     */
+    getReport: (id: string) => BreachReport | null;
+    /**
+     * Conduct a risk assessment for a breach
+     */
+    assessRisk: (breachId: string, assessmentData: Omit<RiskAssessment, 'id' | 'breachId' | 'assessedAt'>) => RiskAssessment;
+    /**
+     * Get a risk assessment for a breach
+     */
+    getAssessment: (breachId: string) => RiskAssessment | null;
+    /**
+     * Calculate notification requirements based on a risk assessment
+     */
+    calculateNotificationRequirements: (breachId: string) => NotificationRequirement | null;
+    /**
+     * Send a regulatory notification
+     */
+    sendNotification: (breachId: string, notificationData: Omit<RegulatoryNotification, 'id' | 'breachId' | 'sentAt'>) => RegulatoryNotification;
+    /**
+     * Get a regulatory notification for a breach
+     */
+    getNotification: (breachId: string) => RegulatoryNotification | null;
+    /**
+     * Get breaches that require notification within the next X hours
+     */
+    getBreachesRequiringNotification: (hoursThreshold?: number) => Array<{
+        report: BreachReport;
+        assessment: RiskAssessment;
+        requirements: NotificationRequirement;
+        hoursRemaining: number;
+    }>;
+    /**
+     * Clear all breach data
+     */
+    clearBreachData: () => void;
+}
+/**
+ * Hook for managing data breach notifications in compliance with NDPR
+ */
+export declare function useBreach({ categories, initialReports, storageKey, useLocalStorage, onReport, onAssessment, onNotification }: UseBreachOptions): UseBreachReturn;
+export {};

package/dist/hooks/useConsent.d.ts

@@ -0,0 +1,63 @@
+import { ConsentOption, ConsentSettings, ConsentStorageOptions } from '../types/consent';
+interface UseConsentOptions {
+    /**
+     * Consent options to present to the user
+     */
+    options: ConsentOption[];
+    /**
+     * Storage options for consent settings
+     */
+    storageOptions?: ConsentStorageOptions;
+    /**
+     * Version of the consent form
+     * @default "1.0"
+     */
+    version?: string;
+    /**
+     * Callback function called when consent settings change
+     */
+    onChange?: (settings: ConsentSettings) => void;
+}
+interface UseConsentReturn {
+    /**
+     * Current consent settings
+     */
+    settings: ConsentSettings | null;
+    /**
+     * Whether consent has been given for a specific option
+     */
+    hasConsent: (optionId: string) => boolean;
+    /**
+     * Update consent settings
+     */
+    updateConsent: (consents: Record<string, boolean>) => void;
+    /**
+     * Accept all consent options
+     */
+    acceptAll: () => void;
+    /**
+     * Reject all non-required consent options
+     */
+    rejectAll: () => void;
+    /**
+     * Whether the consent banner should be shown
+     */
+    shouldShowBanner: boolean;
+    /**
+     * Whether consent settings are valid
+     */
+    isValid: boolean;
+    /**
+     * Validation errors (if any)
+     */
+    validationErrors: string[];
+    /**
+     * Reset consent settings (clear from storage)
+     */
+    resetConsent: () => void;
+}
+/**
+ * Hook for managing user consent in compliance with NDPR
+ */
+export declare function useConsent({ options, storageOptions, version, onChange }: UseConsentOptions): UseConsentReturn;
+export {};

package/dist/hooks/useDPIA.d.ts

@@ -0,0 +1,92 @@
+import { DPIAQuestion, DPIASection, DPIAResult } from '../types/dpia';
+interface UseDPIAOptions {
+    /**
+     * Sections of the DPIA questionnaire
+     */
+    sections: DPIASection[];
+    /**
+     * Initial answers (if resuming a DPIA)
+     */
+    initialAnswers?: Record<string, any>;
+    /**
+     * Storage key for DPIA data
+     * @default "ndpr_dpia_data"
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist DPIA data
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when the DPIA is completed
+     */
+    onComplete?: (result: DPIAResult) => void;
+}
+interface UseDPIAReturn {
+    /**
+     * Current section index
+     */
+    currentSectionIndex: number;
+    /**
+     * Current section
+     */
+    currentSection: DPIASection | null;
+    /**
+     * All answers
+     */
+    answers: Record<string, any>;
+    /**
+     * Update an answer
+     */
+    updateAnswer: (questionId: string, value: any) => void;
+    /**
+     * Go to the next section
+     */
+    nextSection: () => boolean;
+    /**
+     * Go to the previous section
+     */
+    prevSection: () => boolean;
+    /**
+     * Go to a specific section
+     */
+    goToSection: (index: number) => boolean;
+    /**
+     * Check if the current section is valid
+     */
+    isCurrentSectionValid: () => boolean;
+    /**
+     * Get validation errors for the current section
+     */
+    getCurrentSectionErrors: () => Record<string, string>;
+    /**
+     * Check if the DPIA is complete
+     */
+    isComplete: () => boolean;
+    /**
+     * Complete the DPIA and generate a result
+     */
+    completeDPIA: (assessorInfo: {
+        name: string;
+        role: string;
+        email: string;
+    }, title: string, processingDescription: string) => DPIAResult;
+    /**
+     * Get the visible questions for the current section
+     */
+    getVisibleQuestions: () => DPIAQuestion[];
+    /**
+     * Reset the DPIA
+     */
+    resetDPIA: () => void;
+    /**
+     * Progress percentage
+     */
+    progress: number;
+}
+/**
+ * Hook for conducting Data Protection Impact Assessments in compliance with NDPR
+ */
+export declare function useDPIA({ sections, initialAnswers, storageKey, useLocalStorage, onComplete }: UseDPIAOptions): UseDPIAReturn;
+export {};

package/dist/hooks/useDSR.d.ts

@@ -0,0 +1,72 @@
+import { DSRRequest, RequestStatus, RequestType } from '../types/dsr';
+interface UseDSROptions {
+    /**
+     * Initial requests to load
+     */
+    initialRequests?: DSRRequest[];
+    /**
+     * Available request types
+     */
+    requestTypes: RequestType[];
+    /**
+     * Storage key for requests
+     * @default "ndpr_dsr_requests"
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist requests
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a request is submitted
+     */
+    onSubmit?: (request: DSRRequest) => void;
+    /**
+     * Callback function called when a request is updated
+     */
+    onUpdate?: (request: DSRRequest) => void;
+}
+interface UseDSRReturn {
+    /**
+     * All requests
+     */
+    requests: DSRRequest[];
+    /**
+     * Submit a new request
+     */
+    submitRequest: (requestData: Omit<DSRRequest, 'id' | 'status' | 'submittedAt' | 'updatedAt' | 'estimatedCompletionDate'>) => DSRRequest;
+    /**
+     * Update an existing request
+     */
+    updateRequest: (id: string, updates: Partial<DSRRequest>) => DSRRequest | null;
+    /**
+     * Get a request by ID
+     */
+    getRequest: (id: string) => DSRRequest | null;
+    /**
+     * Get requests by status
+     */
+    getRequestsByStatus: (status: RequestStatus) => DSRRequest[];
+    /**
+     * Get requests by type
+     */
+    getRequestsByType: (type: string) => DSRRequest[];
+    /**
+     * Get the request type definition by ID
+     */
+    getRequestType: (typeId: string) => RequestType | undefined;
+    /**
+     * Format a request for display or submission
+     */
+    formatRequest: (request: DSRRequest) => Record<string, any>;
+    /**
+     * Clear all requests
+     */
+    clearRequests: () => void;
+}
+/**
+ * Hook for managing Data Subject Requests in compliance with NDPR
+ */
+export declare function useDSR({ initialRequests, requestTypes, storageKey, useLocalStorage, onSubmit, onUpdate }: UseDSROptions): UseDSRReturn;
+export {};

package/dist/hooks/usePrivacyPolicy.d.ts

@@ -0,0 +1,87 @@
+import { PolicyTemplate, OrganizationInfo, PrivacyPolicy } from '../types/privacy';
+interface UsePrivacyPolicyOptions {
+    /**
+     * Available policy templates
+     */
+    templates: PolicyTemplate[];
+    /**
+     * Initial policy data (if editing an existing policy)
+     */
+    initialPolicy?: PrivacyPolicy;
+    /**
+     * Storage key for policy data
+     * @default "ndpr_privacy_policy"
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist policy data
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a policy is generated
+     */
+    onGenerate?: (policy: PrivacyPolicy) => void;
+}
+interface UsePrivacyPolicyReturn {
+    /**
+     * Current policy data
+     */
+    policy: PrivacyPolicy | null;
+    /**
+     * Selected template
+     */
+    selectedTemplate: PolicyTemplate | null;
+    /**
+     * Organization information
+     */
+    organizationInfo: OrganizationInfo;
+    /**
+     * Select a template
+     */
+    selectTemplate: (templateId: string) => boolean;
+    /**
+     * Update organization information
+     */
+    updateOrganizationInfo: (updates: Partial<OrganizationInfo>) => void;
+    /**
+     * Toggle whether a section is included in the policy
+     */
+    toggleSection: (sectionId: string, included: boolean) => void;
+    /**
+     * Update section content
+     */
+    updateSectionContent: (sectionId: string, content: string) => void;
+    /**
+     * Update variable values
+     */
+    updateVariableValue: (variable: string, value: string) => void;
+    /**
+     * Generate the policy
+     */
+    generatePolicy: () => PrivacyPolicy;
+    /**
+     * Get the generated policy text
+     */
+    getPolicyText: () => {
+        fullText: string;
+        sectionTexts: Record<string, string>;
+        missingVariables: string[];
+    };
+    /**
+     * Reset the policy
+     */
+    resetPolicy: () => void;
+    /**
+     * Check if the policy is valid
+     */
+    isValid: () => {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * Hook for generating NDPR-compliant privacy policies
+ */
+export declare function usePrivacyPolicy({ templates, initialPolicy, storageKey, useLocalStorage, onGenerate }: UsePrivacyPolicyOptions): UsePrivacyPolicyReturn;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { ConsentBanner } from './components/consent/ConsentBanner';
+export { ConsentManager } from './components/consent/ConsentManager';
+export { ConsentStorage } from './components/consent/ConsentStorage';
+export type { ConsentOption, ConsentSettings, ConsentStorageOptions } from './types/consent';
+export { DSRRequestForm } from './components/dsr/DSRRequestForm';
+export { DSRDashboard } from './components/dsr/DSRDashboard';
+export { DSRTracker } from './components/dsr/DSRTracker';
+export type { DSRRequest, RequestType, DSRStatus, DSRType, RequestStatus } from './types/dsr';
+export { DPIAQuestionnaire } from './components/dpia/DPIAQuestionnaire';
+export { DPIAReport } from './components/dpia/DPIAReport';
+export { StepIndicator } from './components/dpia/StepIndicator';
+export type { DPIAQuestion, DPIASection, DPIAResult } from './types/dpia';
+export { BreachReportForm } from './components/breach/BreachReportForm';
+export { BreachRiskAssessment } from './components/breach/BreachRiskAssessment';
+export { BreachNotificationManager } from './components/breach/BreachNotificationManager';
+export { RegulatoryReportGenerator } from './components/breach/RegulatoryReportGenerator';
+export type { BreachReport, RiskAssessment, NotificationRequirement } from './types/breach';
+export { PolicyGenerator } from './components/policy/PolicyGenerator';
+export { PolicyPreview } from './components/policy/PolicyPreview';
+export { PolicyExporter } from './components/policy/PolicyExporter';
+export type { PolicySection, PolicyTemplate, PolicyVariable, OrganizationInfo, PrivacyPolicy } from './types/privacy';
+export { validateConsent } from './utils/consent';
+export { formatDSRRequest } from './utils/dsr';
+export { assessDPIARisk } from './utils/dpia';
+export { calculateBreachSeverity } from './utils/breach';
+export { generatePolicyText } from './utils/privacy';
+export { useConsent } from './hooks/useConsent';
+export { useDSR } from './hooks/useDSR';
+export { useDPIA } from './hooks/useDPIA';
+export { useBreach } from './hooks/useBreach';
+export { usePrivacyPolicy } from './hooks/usePrivacyPolicy';