@tantainnovative/ndpr-toolkit 1.0.4 → 1.0.5

package/src/lib/storage.ts

@@ -0,0 +1,222 @@
+"use client";
+
+/**
+ * Safe localStorage wrapper with error handling
+ */
+export class SafeStorage {
+  private static isStorageAvailable(): boolean {
+    if (typeof window === "undefined") return false;
+
+    try {
+      const testKey = "__storage_test__";
+      window.localStorage.setItem(testKey, "test");
+      window.localStorage.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static getItem<T = unknown>(key: string, defaultValue?: T): T | null {
+    if (!this.isStorageAvailable()) {
+      console.warn("localStorage is not available");
+      return defaultValue ?? null;
+    }
+
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) return defaultValue ?? null;
+
+      // Try to parse as JSON, otherwise return as string
+      try {
+        return JSON.parse(item) as T;
+      } catch {
+        return item as unknown as T;
+      }
+    } catch (error) {
+      console.error(`Error reading from localStorage: ${key}`, error);
+      return defaultValue ?? null;
+    }
+  }
+
+  static setItem(key: string, value: unknown): boolean {
+    if (!this.isStorageAvailable()) {
+      console.warn("localStorage is not available");
+      return false;
+    }
+
+    try {
+      const serialized =
+        typeof value === "string" ? value : JSON.stringify(value);
+      window.localStorage.setItem(key, serialized);
+      return true;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "QuotaExceededError") {
+          console.error("localStorage quota exceeded");
+          // Try to clear old data
+          this.clearOldData();
+          // Retry once
+          try {
+            const serialized =
+              typeof value === "string" ? value : JSON.stringify(value);
+            window.localStorage.setItem(key, serialized);
+            return true;
+          } catch {
+            console.error("Failed to save after clearing old data");
+            return false;
+          }
+        }
+      }
+      console.error(`Error writing to localStorage: ${key}`, error);
+      return false;
+    }
+  }
+
+  static removeItem(key: string): boolean {
+    if (!this.isStorageAvailable()) {
+      console.warn("localStorage is not available");
+      return false;
+    }
+
+    try {
+      window.localStorage.removeItem(key);
+      return true;
+    } catch (error) {
+      console.error(`Error removing from localStorage: ${key}`, error);
+      return false;
+    }
+  }
+
+  static clear(): boolean {
+    if (!this.isStorageAvailable()) {
+      console.warn("localStorage is not available");
+      return false;
+    }
+
+    try {
+      window.localStorage.clear();
+      return true;
+    } catch (error) {
+      console.error("Error clearing localStorage", error);
+      return false;
+    }
+  }
+
+  /**
+   * Get storage size in bytes
+   */
+  static getStorageSize(): number {
+    if (!this.isStorageAvailable()) return 0;
+
+    let size = 0;
+    try {
+      for (const key in window.localStorage) {
+        if (window.localStorage.hasOwnProperty(key)) {
+          size += window.localStorage[key].length + key.length;
+        }
+      }
+    } catch (error) {
+      console.error("Error calculating storage size", error);
+    }
+    return size;
+  }
+
+  /**
+   * Clear old data based on timestamp
+   * Removes items older than specified days
+   */
+  static clearOldData(daysOld: number = 30): void {
+    if (!this.isStorageAvailable()) return;
+
+    const cutoffTime = Date.now() - daysOld * 24 * 60 * 60 * 1000;
+    const keysToRemove: string[] = [];
+
+    try {
+      for (const key in window.localStorage) {
+        if (window.localStorage.hasOwnProperty(key)) {
+          try {
+            const item = window.localStorage.getItem(key);
+            if (item) {
+              const parsed = JSON.parse(item);
+              if (parsed.timestamp && parsed.timestamp < cutoffTime) {
+                keysToRemove.push(key);
+              }
+            }
+          } catch {
+            // If parsing fails, skip this item
+          }
+        }
+      }
+
+      // Remove old items
+      keysToRemove.forEach((key) => this.removeItem(key));
+    } catch (error) {
+      console.error("Error clearing old data", error);
+    }
+  }
+
+  /**
+   * Wrapper for data with timestamp
+   */
+  static setItemWithTimestamp(key: string, value: unknown): boolean {
+    const wrappedData = {
+      data: value,
+      timestamp: Date.now(),
+    };
+    return this.setItem(key, wrappedData);
+  }
+
+  /**
+   * Get item with timestamp check
+   */
+  static getItemWithTimestamp<T = unknown>(
+    key: string,
+    maxAge?: number,
+  ): T | null {
+    const wrapped = this.getItem<{ data: T; timestamp: number }>(key);
+    if (!wrapped) return null;
+
+    if (maxAge && wrapped.timestamp) {
+      const age = Date.now() - wrapped.timestamp;
+      if (age > maxAge) {
+        this.removeItem(key);
+        return null;
+      }
+    }
+
+    return wrapped.data;
+  }
+}
+
+// Retry decorator for storage operations
+export function withRetry<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  maxRetries: number = 3,
+  delay: number = 100,
+): T {
+  return ((...args: Parameters<T>) => {
+    let lastError: Error | null = null;
+
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return fn(...args);
+      } catch (error) {
+        lastError = error as Error;
+        if (i < maxRetries - 1) {
+          // Wait before retrying
+          const waitTime = delay * Math.pow(2, i); // Exponential backoff
+          const start = Date.now();
+          while (Date.now() - start < waitTime) {
+            // Busy wait
+          }
+        }
+      }
+    }
+
+    throw lastError;
+  }) as T;
+}
+
+// Export a default instance
+export const storage = SafeStorage;

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/types/html-to-docx.d.ts

@@ -0,0 +1,30 @@
+declare module 'html-to-docx' {
+  export default function htmlToDocx(
+    htmlString: string,
+    options?: {
+      title?: string;
+      margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+      };
+      header?: {
+        default?: string;
+        first?: string;
+        even?: string;
+      };
+      footer?: {
+        default?: string;
+        first?: string;
+        even?: string;
+      };
+      pageNumber?: boolean;
+      orientation?: 'portrait' | 'landscape';
+      font?: {
+        family?: string;
+        size?: number;
+      };
+    }
+  ): Promise<Buffer>;
+}

package/src/types/index.ts

@@ -0,0 +1,77 @@
+// Re-export all types from the package
+// This ensures consistency between the main app and the package
+export * from "@tantainnovative/ndpr-toolkit";
+import type { DSRStatus, DSRType } from "@tantainnovative/ndpr-toolkit";
+
+// Additional app-specific types that extend the package types
+export interface AppConfig {
+  apiUrl?: string;
+  environment: "development" | "staging" | "production";
+  features: {
+    consent: boolean;
+    dsr: boolean;
+    dpia: boolean;
+    breach: boolean;
+    privacy: boolean;
+  };
+}
+
+// Legacy type aliases for backward compatibility
+// These map old type names to new ones from the package
+export type RequestStatus = DSRStatus;
+export type RequestType = DSRType;
+
+// Re-export specific types that might have different names
+export type {
+  ConsentOption,
+  BreachReport,
+  RiskAssessment,
+  NotificationRequirement,
+  RegulatoryNotification,
+  DSRRequest as DataSubjectRequest,
+  DSRStatus,
+  DSRType,
+  PrivacyPolicy,
+  PolicySection,
+  PolicyTemplate,
+  PolicyVariable,
+  OrganizationInfo,
+  DPIAQuestion as RiskAssessmentQuestion,
+  DPIASection,
+  DPIAResult,
+} from "@tantainnovative/ndpr-toolkit";
+
+// Define ConsentType locally since it's not exported from the package
+export type ConsentType =
+  | "necessary"
+  | "functional"
+  | "analytics"
+  | "marketing"
+  | "preferences";
+
+// Define BreachSeverity type
+export type BreachSeverity = "low" | "medium" | "high" | "critical";
+
+// Define missing types that are not exported from the package
+export interface ConsentRecord {
+  id: string;
+  userId?: string;
+  consents: Record<string, boolean>;
+  timestamp: Date;
+  ipAddress?: string;
+  userAgent?: string;
+  version: string;
+}
+
+export interface ConsentHistoryEntry {
+  timestamp: Date;
+  consents: Record<string, boolean>;
+  action: "granted" | "revoked" | "updated";
+  ipAddress?: string;
+  userAgent?: string;
+  version: string;
+}
+
+export interface ConsentPreferences {
+  [key: string]: boolean;
+}

package/tailwind.config.ts

@@ -0,0 +1,65 @@
+import type { Config } from "tailwindcss";
+
+const config: Config = {
+  darkMode: ["class", '[data-theme="dark"]'],
+  content: [
+    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "var(--border)",
+        input: "var(--input)",
+        ring: "var(--ring)",
+        background: "var(--background)",
+        foreground: "var(--foreground)",
+        primary: {
+          DEFAULT: "var(--primary)",
+          foreground: "var(--primary-foreground)",
+        },
+        secondary: {
+          DEFAULT: "var(--secondary)",
+          foreground: "var(--secondary-foreground)",
+        },
+        destructive: {
+          DEFAULT: "var(--destructive)",
+          foreground: "var(--destructive-foreground, var(--foreground))",
+        },
+        muted: {
+          DEFAULT: "var(--muted)",
+          foreground: "var(--muted-foreground)",
+        },
+        accent: {
+          DEFAULT: "var(--accent)",
+          foreground: "var(--accent-foreground)",
+        },
+        popover: {
+          DEFAULT: "var(--popover)",
+          foreground: "var(--popover-foreground)",
+        },
+        card: {
+          DEFAULT: "var(--card)",
+          foreground: "var(--card-foreground)",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius-lg)",
+        md: "var(--radius-md)",
+        sm: "var(--radius-sm)",
+        xl: "var(--radius-xl)",
+      },
+    },
+  },
+  plugins: [],
+};
+
+export default config;

package/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "next-env.d.ts",
+    "out/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}