indas-ui 0.0.1 → 0.1.0

package/dist/cjs/lib/security/rate-limiter.js

@@ -0,0 +1,122 @@
+'use client';
+"use strict";
+// Production-grade rate limiter using C# backend API with MSSQL database
+// Distributed and persisted across server restarts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimiter = void 0;
+exports.getClientIP = getClientIP;
+class RateLimiter {
+    constructor() {
+        this.apiBaseUrl = process.env.NEXT_PUBLIC_API_BASE_URL || '';
+    }
+    /**
+     * Check if a request should be rate limited using backend API
+     * @param identifier - Usually IP address or username
+     * @param maxAttempts - Maximum attempts allowed in the window
+     * @param windowMs - Time window in milliseconds
+     * @returns Object with allowed status and remaining attempts
+     */
+    async check(identifier, maxAttempts = 5, windowMs = 15 * 60 * 1000, // 15 minutes default
+    identifierType = 'USERNAME') {
+        try {
+            const windowMinutes = Math.floor(windowMs / 60000);
+            const blockMinutes = windowMinutes; // Block for same duration as window
+            const response = await fetch(`${this.apiBaseUrl}/api/security/ratelimit/check`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    Identifier: identifier,
+                    IdentifierType: identifierType,
+                    MaxAttempts: maxAttempts,
+                    WindowMinutes: windowMinutes,
+                    BlockMinutes: blockMinutes
+                })
+            });
+            if (response.ok) {
+                const result = await response.json();
+                return {
+                    allowed: result.allowed,
+                    remaining: result.remaining,
+                    resetIn: result.resetIn * 1000 // Convert seconds to milliseconds
+                };
+            }
+            // If API fails, allow the request (fail open)
+            console.error('Rate limit check failed, allowing request');
+            return {
+                allowed: true,
+                remaining: maxAttempts,
+                resetIn: windowMs
+            };
+        }
+        catch (error) {
+            // If API fails, allow the request (fail open)
+            console.error('Rate limit check error:', error);
+            return {
+                allowed: true,
+                remaining: maxAttempts,
+                resetIn: windowMs
+            };
+        }
+    }
+    /**
+     * Reset rate limit for an identifier (e.g., after successful login)
+     */
+    async reset(identifier, identifierType = 'USERNAME') {
+        try {
+            await fetch(`${this.apiBaseUrl}/api/security/ratelimit/reset`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    Identifier: identifier,
+                    IdentifierType: identifierType
+                })
+            });
+        }
+        catch (error) {
+            console.error('Rate limit reset error:', error);
+        }
+    }
+    /**
+     * Get current stats for an identifier (for debugging)
+     */
+    async getStats(identifier, identifierType = 'USERNAME') {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/api/security/ratelimit/status?identifier=${encodeURIComponent(identifier)}&identifierType=${identifierType}`);
+            if (response.ok) {
+                const result = await response.json();
+                return result.data;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Failed to get rate limit stats:', error);
+            return null;
+        }
+    }
+}
+// Export singleton instance
+exports.rateLimiter = new RateLimiter();
+// Helper function to get client IP from request
+function getClientIP(request) {
+    // Try various headers in order of preference
+    const headers = [
+        'x-real-ip',
+        'x-forwarded-for',
+        'cf-connecting-ip', // Cloudflare
+        'true-client-ip', // Cloudflare Enterprise
+        'x-client-ip'
+    ];
+    for (const header of headers) {
+        const value = request.headers.get(header);
+        if (value) {
+            // x-forwarded-for can contain multiple IPs, take the first one
+            return value.split(',')[0].trim();
+        }
+    }
+    // Fallback to 'unknown' if no IP found
+    return 'unknown';
+}

package/dist/cjs/lib/server-url.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerBaseURL = getServerBaseURL;
+exports.getCurrentURL = getCurrentURL;
+exports.mapPath = mapPath;
+exports.getClientBaseURL = getClientBaseURL;
+// Server-side URL utilities (using dynamic host detection)
+const headers_1 = require("next/headers");
+/**
+ * Gets the current server URL dynamically using request headers
+ * No hardcoded values - truly production ready
+ */
+async function getServerBaseURL() {
+    try {
+        // Get headers to determine current URL dynamically
+        const headersList = await (0, headers_1.headers)();
+        const host = headersList.get('host');
+        // Detect protocol dynamically
+        const forwardedProto = headersList.get('x-forwarded-proto');
+        const forwardedSsl = headersList.get('x-forwarded-ssl');
+        const isSecure = forwardedProto === 'https' || forwardedSsl === 'on';
+        const protocol = isSecure ? 'https' : 'http';
+        if (host) {
+            const baseUrl = `${protocol}://${host}`;
+            return baseUrl;
+        }
+        throw new Error('No host header found in request');
+    }
+    catch (error) {
+        console.error('Error detecting server URL:', error);
+        throw error; // Don't return fallback, let caller handle
+    }
+}
+/**
+ * Gets the current request URL (full path)
+ */
+async function getCurrentURL() {
+    try {
+        const headersList = await (0, headers_1.headers)();
+        const host = headersList.get('host');
+        const protocol = headersList.get('x-forwarded-proto') ||
+            (headersList.get('x-forwarded-ssl') === 'on' ? 'https' : 'http');
+        const pathname = headersList.get('x-pathname') || '/';
+        if (host) {
+            return `${protocol}://${host}${pathname}`;
+        }
+        // Fallback to NEXTAUTH_URL environment variable
+        return `${process.env.NEXTAUTH_URL}/`;
+    }
+    catch (error) {
+        console.error('Error getting current URL:', error);
+        // Fallback to NEXTAUTH_URL environment variable
+        return `${process.env.NEXTAUTH_URL}/`;
+    }
+}
+/**
+ * Maps a relative path to absolute URL (like Server.MapPath)
+ */
+async function mapPath(relativePath) {
+    const baseUrl = await getServerBaseURL();
+    // Ensure path starts with /
+    const path = relativePath.startsWith('/') ? relativePath : `/${relativePath}`;
+    return `${baseUrl}${path}`;
+}
+/**
+ * Gets the base URL for client-side usage (window.location based)
+ * Falls back to NEXTAUTH_URL for SSR
+ */
+function getClientBaseURL() {
+    // Client-side: use window.location
+    if (typeof window !== 'undefined') {
+        return `${window.location.protocol}//${window.location.host}`;
+    }
+    // Server-side: use environment variable
+    return process.env.NEXTAUTH_URL;
+}

package/dist/cjs/lib/svg-utils.js

@@ -0,0 +1,213 @@
+'use client';
+"use strict";
+/**
+ * SVG Drawing Utilities
+ * Reusable functions for drawing SVG elements like dimension arrows, text, shapes, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawText = drawText;
+exports.drawRectangle = drawRectangle;
+exports.drawLine = drawLine;
+exports.drawDimensionArrow = drawDimensionArrow;
+exports.drawPolygon = drawPolygon;
+function drawText({ svg, x, y, text, fontSize, color, fontWeight = 'normal', textAnchor = 'middle', dominantBaseline = 'middle' }) {
+    const textEl = document.createElementNS("http://www.w3.org/2000/svg", 'text');
+    textEl.setAttribute('x', x.toString());
+    textEl.setAttribute('y', y.toString());
+    textEl.setAttribute('font-size', fontSize.toString());
+    textEl.setAttribute('fill', color);
+    textEl.setAttribute('font-weight', fontWeight);
+    textEl.setAttribute('text-anchor', textAnchor);
+    textEl.setAttribute('dominant-baseline', dominantBaseline);
+    textEl.textContent = text;
+    svg.appendChild(textEl);
+}
+function drawRectangle({ svg, x, y, width, height, borderColor, borderWidth, fillColor, fillOpacity = 1, rx = 0 }) {
+    if (isNaN(x) || isNaN(y) || isNaN(width) || isNaN(height))
+        return;
+    const rect = document.createElementNS("http://www.w3.org/2000/svg", 'rect');
+    rect.setAttributeNS(null, "x", x.toString());
+    rect.setAttributeNS(null, "y", y.toString());
+    rect.setAttributeNS(null, "width", width.toString());
+    rect.setAttributeNS(null, "height", height.toString());
+    rect.setAttributeNS(null, "stroke", borderColor);
+    rect.setAttributeNS(null, "stroke-width", borderWidth.toString());
+    rect.setAttributeNS(null, "fill", fillColor);
+    rect.setAttributeNS(null, "fill-opacity", fillOpacity.toString());
+    if (rx > 0) {
+        rect.setAttributeNS(null, "rx", rx.toString());
+    }
+    svg.appendChild(rect);
+}
+function drawLine({ svg, x1, y1, x2, y2, color, width, dashArray, opacity = 1 }) {
+    if (isNaN(x1) || isNaN(y1) || isNaN(x2) || isNaN(y2))
+        return;
+    const line = document.createElementNS("http://www.w3.org/2000/svg", 'line');
+    line.setAttribute("x1", x1.toString());
+    line.setAttribute("y1", y1.toString());
+    line.setAttribute("x2", x2.toString());
+    line.setAttribute("y2", y2.toString());
+    line.setAttribute("stroke", color);
+    line.setAttribute("stroke-width", width.toString());
+    if (dashArray) {
+        line.setAttribute("stroke-dasharray", dashArray);
+    }
+    if (opacity < 1) {
+        line.setAttribute("opacity", opacity.toString());
+    }
+    svg.appendChild(line);
+}
+function drawDimensionArrow({ svg, x1, y1, x2, y2, label, isVertical = false, offset = 10 }) {
+    if (isNaN(x1) || isNaN(y1) || isNaN(x2) || isNaN(y2))
+        return;
+    // Wrap all dimension elements in a group so exports can strip them
+    const childCountBefore = svg.childElementCount;
+    const lineColor = "#1e293b"; // Slate-800 - professional dark
+    const arrowColor = "#0f172a"; // Slate-900 - maximum contrast
+    const lineWidth = 1.5;
+    // Main dimension line
+    drawLine({
+        svg,
+        x1,
+        y1,
+        x2,
+        y2,
+        color: lineColor,
+        width: lineWidth
+    });
+    // Arrowheads - sleek triangular design
+    const arrowSize = 7;
+    if (isVertical) {
+        // Vertical arrow - pointing up at start
+        const arrow1 = document.createElementNS("http://www.w3.org/2000/svg", 'polygon');
+        arrow1.setAttribute("points", `${x1},${y1} ${x1 - arrowSize / 2},${y1 + arrowSize} ${x1 + arrowSize / 2},${y1 + arrowSize}`);
+        arrow1.setAttribute("fill", arrowColor);
+        arrow1.setAttribute("stroke", "none");
+        svg.appendChild(arrow1);
+        // Arrowhead at end - pointing down
+        const arrow2 = document.createElementNS("http://www.w3.org/2000/svg", 'polygon');
+        arrow2.setAttribute("points", `${x2},${y2} ${x2 - arrowSize / 2},${y2 - arrowSize} ${x2 + arrowSize / 2},${y2 - arrowSize}`);
+        arrow2.setAttribute("fill", arrowColor);
+        arrow2.setAttribute("stroke", "none");
+        svg.appendChild(arrow2);
+    }
+    else {
+        // Horizontal arrow - pointing left at start
+        const arrow1 = document.createElementNS("http://www.w3.org/2000/svg", 'polygon');
+        arrow1.setAttribute("points", `${x1},${y1} ${x1 + arrowSize},${y1 - arrowSize / 2} ${x1 + arrowSize},${y1 + arrowSize / 2}`);
+        arrow1.setAttribute("fill", arrowColor);
+        arrow1.setAttribute("stroke", "none");
+        svg.appendChild(arrow1);
+        // Arrowhead at end - pointing right
+        const arrow2 = document.createElementNS("http://www.w3.org/2000/svg", 'polygon');
+        arrow2.setAttribute("points", `${x2},${y2} ${x2 - arrowSize},${y2 - arrowSize / 2} ${x2 - arrowSize},${y2 + arrowSize / 2}`);
+        arrow2.setAttribute("fill", arrowColor);
+        arrow2.setAttribute("stroke", "none");
+        svg.appendChild(arrow2);
+    }
+    // Label with professional styling
+    const labelX = (x1 + x2) / 2;
+    const labelY = (y1 + y2) / 2;
+    // Compact label sizing
+    const padding = 5;
+    const fontSize = 12;
+    const textWidth = label.length * 7;
+    const textHeight = fontSize + 2;
+    if (isVertical) {
+        // For vertical arrows, rotate the text 90 degrees counterclockwise
+        // Background rectangle (rotated) - subtle shadow effect
+        const shadow = document.createElementNS("http://www.w3.org/2000/svg", 'rect');
+        shadow.setAttribute("x", (-(textWidth / 2 + padding) + 1).toString());
+        shadow.setAttribute("y", (-(textHeight / 2 + padding) + 1).toString());
+        shadow.setAttribute("width", (textWidth + padding * 2).toString());
+        shadow.setAttribute("height", (textHeight + padding * 2).toString());
+        shadow.setAttribute("fill", "#000000");
+        shadow.setAttribute("opacity", "0.1");
+        shadow.setAttribute("rx", "3");
+        shadow.setAttribute("transform", `translate(${labelX}, ${labelY}) rotate(-90)`);
+        svg.appendChild(shadow);
+        // Background rectangle (rotated)
+        const rect = document.createElementNS("http://www.w3.org/2000/svg", 'rect');
+        rect.setAttribute("x", (-(textWidth / 2 + padding)).toString());
+        rect.setAttribute("y", (-(textHeight / 2 + padding)).toString());
+        rect.setAttribute("width", (textWidth + padding * 2).toString());
+        rect.setAttribute("height", (textHeight + padding * 2).toString());
+        rect.setAttribute("fill", "white");
+        rect.setAttribute("stroke", "#94a3b8"); // Slate-400 - defined border
+        rect.setAttribute("stroke-width", "1");
+        rect.setAttribute("rx", "3");
+        rect.setAttribute("transform", `translate(${labelX}, ${labelY}) rotate(-90)`);
+        svg.appendChild(rect);
+        // Rotated text
+        const textEl = document.createElementNS("http://www.w3.org/2000/svg", 'text');
+        textEl.setAttribute('x', "0");
+        textEl.setAttribute('y', "0");
+        textEl.setAttribute('font-size', fontSize.toString());
+        textEl.setAttribute('fill', arrowColor);
+        textEl.setAttribute('font-weight', "600");
+        textEl.setAttribute('text-anchor', 'middle');
+        textEl.setAttribute('dominant-baseline', 'middle');
+        textEl.setAttribute('transform', `translate(${labelX}, ${labelY}) rotate(-90)`);
+        textEl.textContent = label;
+        svg.appendChild(textEl);
+    }
+    else {
+        // Horizontal arrow - subtle shadow
+        drawRectangle({
+            svg,
+            x: labelX - textWidth / 2 - padding + 1,
+            y: labelY - textHeight / 2 - padding + 1,
+            width: textWidth + padding * 2,
+            height: textHeight + padding * 2,
+            borderColor: "transparent",
+            borderWidth: 0,
+            fillColor: "#000000",
+            fillOpacity: 0.1,
+            rx: 3
+        });
+        // Horizontal arrow - label background
+        drawRectangle({
+            svg,
+            x: labelX - textWidth / 2 - padding,
+            y: labelY - textHeight / 2 - padding,
+            width: textWidth + padding * 2,
+            height: textHeight + padding * 2,
+            borderColor: "#94a3b8", // Slate-400 - defined border
+            borderWidth: 1,
+            fillColor: "white",
+            fillOpacity: 1,
+            rx: 3
+        });
+        drawText({
+            svg,
+            x: labelX,
+            y: labelY,
+            text: label,
+            fontSize: fontSize,
+            color: arrowColor,
+            fontWeight: "600"
+        });
+    }
+    // Move all newly appended children into a <g data-dimension> group
+    const group = document.createElementNS("http://www.w3.org/2000/svg", 'g');
+    group.setAttribute('data-dimension', 'true');
+    const newChildren = [];
+    for (let i = childCountBefore; i < svg.childElementCount; i++) {
+        newChildren.push(svg.children[i]);
+    }
+    for (const child of newChildren) {
+        group.appendChild(child);
+    }
+    svg.appendChild(group);
+}
+function drawPolygon({ svg, points, fillColor, borderColor, borderWidth = 0, fillOpacity = 1 }) {
+    const polygon = document.createElementNS("http://www.w3.org/2000/svg", 'polygon');
+    polygon.setAttribute("points", points);
+    polygon.setAttribute("fill", fillColor);
+    polygon.setAttribute("fill-opacity", fillOpacity.toString());
+    if (borderColor && borderWidth > 0) {
+        polygon.setAttribute("stroke", borderColor);
+        polygon.setAttribute("stroke-width", borderWidth.toString());
+    }
+    svg.appendChild(polygon);
+}

package/dist/cjs/lib/theme/types.js

@@ -0,0 +1,235 @@
+'use client';
+"use strict";
+// Theme system TypeScript definitions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalThemeStorage = exports.THEME_COLORS = exports.FONT_SCALES = exports.FONT_FAMILIES = exports.THEME_CONFIG = exports.CONTRAST_RATIOS = void 0;
+// WCAG AA Contrast ratios
+exports.CONTRAST_RATIOS = {
+    AA_NORMAL: 4.5,
+    AA_LARGE: 3,
+    AAA_NORMAL: 7,
+    AAA_LARGE: 4.5,
+};
+// Theme configuration
+exports.THEME_CONFIG = {
+    variants: ['default', 'red', 'green', 'purple', 'orange', 'black', 'custom'],
+    modes: ['light', 'dark'],
+    storageKey: 'erp-theme',
+    attribute: 'class',
+};
+// Font family configurations
+exports.FONT_FAMILIES = {
+    system: {
+        name: 'System Default',
+        value: '"Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+        description: 'Inter font (default) - Modern and professional',
+        requiresImport: true
+    },
+    roboto: {
+        name: 'Roboto',
+        value: '"Roboto", -apple-system, sans-serif',
+        description: 'Clean and readable - Google design',
+        requiresImport: true
+    },
+    openSans: {
+        name: 'Open Sans',
+        value: '"Open Sans", -apple-system, sans-serif',
+        description: 'Friendly and approachable - Web standard',
+        requiresImport: true
+    },
+    lato: {
+        name: 'Lato',
+        value: '"Lato", -apple-system, sans-serif',
+        description: 'Elegant and versatile - Corporate',
+        requiresImport: true
+    },
+    poppins: {
+        name: 'Poppins',
+        value: '"Poppins", -apple-system, sans-serif',
+        description: 'Modern geometric - Startups',
+        requiresImport: true
+    },
+    montserrat: {
+        name: 'Montserrat',
+        value: '"Montserrat", -apple-system, sans-serif',
+        description: 'Bold and geometric - Headlines',
+        requiresImport: true
+    },
+    nunito: {
+        name: 'Nunito',
+        value: '"Nunito", -apple-system, sans-serif',
+        description: 'Rounded and friendly - Educational',
+        requiresImport: true
+    },
+    sourceSansPro: {
+        name: 'Source Sans Pro',
+        value: '"Source Sans Pro", -apple-system, sans-serif',
+        description: 'Professional and neutral - Adobe',
+        requiresImport: true
+    },
+    workSans: {
+        name: 'Work Sans',
+        value: '"Work Sans", -apple-system, sans-serif',
+        description: 'Modern and versatile - Digital products',
+        requiresImport: true
+    },
+    ubuntu: {
+        name: 'Ubuntu',
+        value: '"Ubuntu", -apple-system, sans-serif',
+        description: 'Humanist and technical - Linux inspired',
+        requiresImport: true
+    }
+};
+// Font scale configurations (WCAG 2.1 Level AA compliant)
+exports.FONT_SCALES = {
+    small: {
+        name: 'Small',
+        scale: 0.875,
+        description: 'Compact - More content visible',
+        minSize: '12px'
+    },
+    normal: {
+        name: 'Normal',
+        scale: 1.0,
+        description: 'Default - Balanced readability',
+        minSize: '14px'
+    },
+    large: {
+        name: 'Large',
+        scale: 1.125,
+        description: 'Comfortable - Easy reading',
+        minSize: '16px'
+    },
+    extraLarge: {
+        name: 'Extra Large',
+        scale: 1.25,
+        description: 'Accessible - Vision assistance',
+        minSize: '18px'
+    }
+};
+// Pre-defined theme colors (WCAG AA compliant)
+exports.THEME_COLORS = {
+    default: {
+        light: {
+            accent: '#003366', // Your preferred navy blue
+            accentHover: '#002244', // Darker navy blue
+            accentSubtle: '#E6F0FF', // Light blue tint
+            accentMuted: '#6699CC', // Medium blue
+        },
+        dark: {
+            accent: '#4D79A4', // Lighter navy for dark mode
+            accentHover: '#5D89B4', // Hover state for dark mode
+            accentSubtle: '#001122', // Very dark navy
+            accentMuted: '#336699', // Muted navy
+        }
+    },
+    red: {
+        light: {
+            accent: '#EF4444', // Red-500
+            accentHover: '#DC2626', // Red-600
+            accentSubtle: '#FEE2E2', // Red-100
+            accentMuted: '#FCA5A5', // Red-300
+        },
+        dark: {
+            accent: '#F87171', // Red-400
+            accentHover: '#EF4444', // Red-500
+            accentSubtle: '#7F1D1D', // Red-900
+            accentMuted: '#DC2626', // Red-600
+        }
+    },
+    green: {
+        light: {
+            accent: '#22C55E', // Green-500
+            accentHover: '#16A34A', // Green-600
+            accentSubtle: '#DCFCE7', // Green-100
+            accentMuted: '#86EFAC', // Green-300
+        },
+        dark: {
+            accent: '#4ADE80', // Green-400
+            accentHover: '#22C55E', // Green-500
+            accentSubtle: '#14532D', // Green-900
+            accentMuted: '#16A34A', // Green-600
+        }
+    },
+    purple: {
+        light: {
+            accent: '#A855F7', // Purple-500
+            accentHover: '#9333EA', // Purple-600
+            accentSubtle: '#F3E8FF', // Purple-100
+            accentMuted: '#C4B5FD', // Purple-300
+        },
+        dark: {
+            accent: '#C4B5FD', // Purple-400
+            accentHover: '#A855F7', // Purple-500
+            accentSubtle: '#581C87', // Purple-900
+            accentMuted: '#9333EA', // Purple-600
+        }
+    },
+    orange: {
+        light: {
+            accent: '#F97316', // Orange-500
+            accentHover: '#EA580C', // Orange-600
+            accentSubtle: '#FED7AA', // Orange-200
+            accentMuted: '#FB923C', // Orange-400
+        },
+        dark: {
+            accent: '#FB923C', // Orange-400
+            accentHover: '#F97316', // Orange-500
+            accentSubtle: '#7C2D12', // Orange-900
+            accentMuted: '#EA580C', // Orange-600
+        }
+    },
+    black: {
+        light: {
+            accent: '#000000', // Pure Black
+            accentHover: '#1F1F1F', // Gray-900
+            accentSubtle: '#F5F5F5', // Gray-100
+            accentMuted: '#737373', // Gray-500
+        },
+        dark: {
+            accent: '#404040', // Gray-700
+            accentHover: '#525252', // Gray-600
+            accentSubtle: '#0A0A0A', // Almost black
+            accentMuted: '#262626', // Gray-800
+        }
+    }
+};
+// Local storage implementation
+class LocalThemeStorage {
+    async getTheme(key) {
+        try {
+            const stored = localStorage.getItem(key);
+            return stored ? JSON.parse(stored) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async setTheme(key, theme) {
+        localStorage.setItem(key, JSON.stringify(theme));
+    }
+    async getCustomTheme(key) {
+        try {
+            const stored = localStorage.getItem(`${key}-custom`);
+            if (!stored)
+                return null;
+            const parsed = JSON.parse(stored);
+            return {
+                ...parsed,
+                createdAt: new Date(parsed.createdAt),
+                updatedAt: new Date(parsed.updatedAt),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async setCustomTheme(key, theme) {
+        localStorage.setItem(`${key}-custom`, JSON.stringify(theme));
+    }
+    async removeTheme(key) {
+        localStorage.removeItem(key);
+        localStorage.removeItem(`${key}-custom`);
+    }
+}
+exports.LocalThemeStorage = LocalThemeStorage;