xypriss 1.0.0 → 1.0.1

package/dist/cjs/mods/toolkit/src/components/secure-array/events/event-manager.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/***************************************************************************
+ * XyPrissSecurity - Secure Array Event Manager
+ *
+ * This file contains the event management system for SecureArray
+ *
+ * @author Nehonix
+
+ * @license MIT
+ *
+ * Copyright (c) 2025 Nehonix. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ***************************************************************************** */
+/**
+ * Manages events for SecureArray operations
+ */
+class ArrayEventManager {
+    constructor() {
+        this.listeners = new Map();
+        this.eventHistory = [];
+        this.maxHistorySize = 1000;
+    }
+    /**
+     * Adds an event listener
+     */
+    on(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+    }
+    /**
+     * Removes an event listener
+     */
+    off(event, listener) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            return eventListeners.delete(listener);
+        }
+        return false;
+    }
+    /**
+     * Removes all listeners for an event
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    /**
+     * Emits an event to all listeners
+     */
+    emit(event, index, value, metadata) {
+        // Add to history
+        this.addToHistory(event, index, value, metadata);
+        // Emit to listeners
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            for (const listener of eventListeners) {
+                try {
+                    const result = listener(event, index, value, metadata);
+                    // Handle async listeners
+                    if (result instanceof Promise) {
+                        result.catch((error) => {
+                            console.error(`Error in async event listener for ${event}:`, error);
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error(`Error in event listener for ${event}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Adds an event to the history
+     */
+    addToHistory(event, index, value, metadata) {
+        this.eventHistory.push({
+            event,
+            index,
+            value: this.sanitizeValueForHistory(value),
+            metadata,
+            timestamp: new Date(),
+        });
+        // Trim history if it exceeds max size
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+    }
+    /**
+     * Sanitizes sensitive values for history storage
+     */
+    sanitizeValueForHistory(value) {
+        if (typeof value === "string" && value.length > 100) {
+            return `[String: ${value.length} chars]`;
+        }
+        if (value instanceof Uint8Array) {
+            return `[Uint8Array: ${value.length} bytes]`;
+        }
+        if (typeof value === "object" && value !== null) {
+            return `[Object: ${value.constructor?.name || "Unknown"}]`;
+        }
+        return value;
+    }
+    /**
+     * Gets the event history
+     */
+    getHistory(limit) {
+        if (limit) {
+            return this.eventHistory.slice(-limit);
+        }
+        return [...this.eventHistory];
+    }
+    /**
+     * Clears the event history
+     */
+    clearHistory() {
+        this.eventHistory = [];
+    }
+    /**
+     * Sets the maximum history size
+     */
+    setMaxHistorySize(size) {
+        this.maxHistorySize = Math.max(0, size);
+        // Trim current history if necessary
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory = this.eventHistory.slice(-this.maxHistorySize);
+        }
+    }
+    /**
+     * Gets statistics about events
+     */
+    getEventStats() {
+        const eventCounts = new Map();
+        const now = new Date();
+        const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
+        let recentEvents = 0;
+        // Count events in history
+        for (const historyItem of this.eventHistory) {
+            const count = eventCounts.get(historyItem.event) || 0;
+            eventCounts.set(historyItem.event, count + 1);
+            if (historyItem.timestamp > oneHourAgo) {
+                recentEvents++;
+            }
+        }
+        // Count listeners
+        const listenerCounts = new Map();
+        for (const [event, listeners] of this.listeners.entries()) {
+            listenerCounts.set(event, listeners.size);
+        }
+        return {
+            totalEvents: this.eventHistory.length,
+            eventCounts,
+            recentEvents,
+            listenerCounts,
+        };
+    }
+    /**
+     * Gets events by type
+     */
+    getEventsByType(event, limit) {
+        const filtered = this.eventHistory
+            .filter((item) => item.event === event)
+            .map((item) => ({
+            index: item.index,
+            value: item.value,
+            metadata: item.metadata,
+            timestamp: item.timestamp,
+        }));
+        if (limit) {
+            return filtered.slice(-limit);
+        }
+        return filtered;
+    }
+    /**
+     * Gets events within a time range
+     */
+    getEventsInTimeRange(startTime, endTime) {
+        return this.eventHistory.filter((item) => item.timestamp >= startTime && item.timestamp <= endTime);
+    }
+    /**
+     * Checks if there are any listeners for an event
+     */
+    hasListeners(event) {
+        const eventListeners = this.listeners.get(event);
+        return eventListeners ? eventListeners.size > 0 : false;
+    }
+    /**
+     * Gets the number of listeners for an event
+     */
+    getListenerCount(event) {
+        const eventListeners = this.listeners.get(event);
+        return eventListeners ? eventListeners.size : 0;
+    }
+    /**
+     * Gets all registered events
+     */
+    getRegisteredEvents() {
+        return Array.from(this.listeners.keys());
+    }
+    /**
+     * Clears all listeners and history
+     */
+    clear() {
+        this.listeners.clear();
+        this.eventHistory = [];
+    }
+    /**
+     * Creates a one-time listener that removes itself after being called
+     */
+    once(event, listener) {
+        const onceListener = (evt, index, value, metadata) => {
+            this.off(event, onceListener);
+            return listener(evt, index, value, metadata);
+        };
+        this.on(event, onceListener);
+    }
+    /**
+     * Emits an event and waits for all async listeners to complete
+     */
+    async emitAsync(event, index, value, metadata) {
+        // Add to history
+        this.addToHistory(event, index, value, metadata);
+        // Emit to listeners and collect promises
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            const promises = [];
+            for (const listener of eventListeners) {
+                try {
+                    const result = listener(event, index, value, metadata);
+                    if (result instanceof Promise) {
+                        promises.push(result);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error in event listener for ${event}:`, error);
+                }
+            }
+            // Wait for all async listeners to complete
+            if (promises.length > 0) {
+                await Promise.allSettled(promises);
+            }
+        }
+    }
+}
+
+exports.ArrayEventManager = ArrayEventManager;
+//# sourceMappingURL=event-manager.js.map

package/dist/cjs/mods/toolkit/src/components/secure-array/events/event-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-manager.js","sources":["../../../../../../../../mods/toolkit/src/components/secure-array/events/event-manager.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/cjs/mods/toolkit/src/components/secure-array/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var secureArrayCore = require('./core/secure-array-core.js');
+require('../../utils/memory/index.js');
+require('crypto');
+require('../../types/secure-memory.js');
+require('../secure-string/advanced/entropy-analyzer.js');
+require('../secure-string/advanced/quantum-safe.js');
+require('../secure-string/advanced/performance-monitor.js');
+require('../../core/hash/hash-core.js');
+require('../../core/hash/hash-types.js');
+require('../../core/hash/hash-security.js');
+require('../../core/hash/hash-advanced.js');
+require('../../algorithms/hash-algorithms.js');
+require('../../core/random/random-types.js');
+require('../../core/random/random-sources.js');
+require('nehonix-uri-processor');
+require('../../types.js');
+require('nehoid');
+var idGenerator = require('./utils/id-generator.js');
+
+/***************************************************************************
+ * XyPrissSecurity - Secure Array Main Export
+ *
+ * This file contains the main exports for the SecureArray module
+ *
+ * @author Nehonix
+ *
+ * @license MIT
+ *
+ * Copyright (c) 2025 Nehonix. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ***************************************************************************** */
+/**
+ * Main export file for SecureArray
+ */
+// Import the main SecureArray class
+/**
+ * Creates a SecureArray with initial data
+ */
+function createSecureArray(initialData, options) {
+    return new secureArrayCore.SecureArray(initialData, options);
+}
+
+exports.SecureArray = secureArrayCore.SecureArray;
+exports.default = secureArrayCore.SecureArray;
+exports.ArrayIdGenerator = idGenerator.ArrayIdGenerator;
+exports.createSecureArray = createSecureArray;
+//# sourceMappingURL=index.js.map

package/dist/cjs/mods/toolkit/src/components/secure-array/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../mods/toolkit/src/components/secure-array/index.ts"],"sourcesContent":[null],"names":["SecureArray"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BiF;AAEjF;;AAEG;AAEH;AA0DA;;AAEG;AACa,SAAA,iBAAiB,CAG7B,WAAgC,EAChC,OAA4B,EAAA;AAE5B,IAAA,OAAO,IAAIA,2BAAW,CAClB,WAAiC,EACjC,OAAO,CACV,CAAC;AACN;;;;;;;"}

package/dist/cjs/mods/toolkit/src/components/secure-array/metadata/metadata-manager.js

@@ -0,0 +1,331 @@
+'use strict';
+
+/***************************************************************************
+ * XyPrissSecurity - Secure Array Metadata Manager
+ *
+ * This file contains the metadata management system for SecureArray
+ *
+ * @author Nehonix
+ *
+ * @license MIT
+ *
+ * Copyright (c) 2025 Nehonix. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ***************************************************************************** */
+/**
+ * Manages metadata for SecureArray elements
+ */
+class ArrayMetadataManager {
+    constructor() {
+        this.metadata = new Map();
+    }
+    /**
+     * Updates metadata for an element at the specified index
+     */
+    update(index, type, isSecure, accessed = false) {
+        const existing = this.metadata.get(index);
+        const now = new Date();
+        if (existing) {
+            existing.type = type;
+            existing.isSecure = isSecure;
+            if (accessed) {
+                existing.lastAccessed = now;
+                existing.accessCount++;
+            }
+        }
+        else {
+            this.metadata.set(index, {
+                type,
+                isSecure,
+                created: now,
+                lastAccessed: now,
+                accessCount: accessed ? 1 : 0,
+                index,
+            });
+        }
+    }
+    /**
+     * Gets metadata for an element at the specified index
+     */
+    get(index) {
+        return this.metadata.get(index);
+    }
+    /**
+     * Checks if metadata exists for an element at the specified index
+     */
+    has(index) {
+        return this.metadata.has(index);
+    }
+    /**
+     * Deletes metadata for an element at the specified index
+     */
+    delete(index) {
+        return this.metadata.delete(index);
+    }
+    /**
+     * Gets all metadata
+     */
+    getAll() {
+        return new Map(this.metadata);
+    }
+    /**
+     * Clears all metadata
+     */
+    clear() {
+        this.metadata.clear();
+    }
+    /**
+     * Gets statistics about the metadata
+     */
+    getStats() {
+        if (this.metadata.size === 0) {
+            return {
+                totalElements: 0,
+                secureElements: 0,
+                totalAccesses: 0,
+                averageAccessCount: 0,
+                oldestElement: null,
+                newestElement: null,
+            };
+        }
+        let secureElements = 0;
+        let totalAccesses = 0;
+        let oldestElement = null;
+        let newestElement = null;
+        for (const metadata of this.metadata.values()) {
+            if (metadata.isSecure) {
+                secureElements++;
+            }
+            totalAccesses += metadata.accessCount;
+            if (!oldestElement || metadata.created < oldestElement) {
+                oldestElement = metadata.created;
+            }
+            if (!newestElement || metadata.created > newestElement) {
+                newestElement = metadata.created;
+            }
+        }
+        return {
+            totalElements: this.metadata.size,
+            secureElements,
+            totalAccesses,
+            averageAccessCount: totalAccesses / this.metadata.size,
+            oldestElement,
+            newestElement,
+        };
+    }
+    /**
+     * Compacts metadata by removing entries for indices that no longer exist
+     */
+    compact(maxIndex) {
+        const toDelete = [];
+        for (const index of this.metadata.keys()) {
+            if (index >= maxIndex) {
+                toDelete.push(index);
+            }
+        }
+        for (const index of toDelete) {
+            this.metadata.delete(index);
+        }
+    }
+    /**
+     * Shifts metadata indices when elements are inserted or removed
+     */
+    shiftIndices(startIndex, shift) {
+        const newMetadata = new Map();
+        for (const [index, metadata] of this.metadata.entries()) {
+            if (index >= startIndex) {
+                const newIndex = index + shift;
+                if (newIndex >= 0) {
+                    metadata.index = newIndex;
+                    newMetadata.set(newIndex, metadata);
+                }
+            }
+            else {
+                newMetadata.set(index, metadata);
+            }
+        }
+        this.metadata = newMetadata;
+    }
+    /**
+     * Gets metadata for secure elements only
+     */
+    getSecureElementsMetadata() {
+        const secureMetadata = new Map();
+        for (const [index, metadata] of this.metadata.entries()) {
+            if (metadata.isSecure) {
+                secureMetadata.set(index, metadata);
+            }
+        }
+        return secureMetadata;
+    }
+    /**
+     * Gets elements that haven't been accessed recently
+     */
+    getStaleElements(maxAge) {
+        const now = new Date();
+        const staleIndices = [];
+        for (const [index, metadata] of this.metadata.entries()) {
+            const age = now.getTime() - metadata.lastAccessed.getTime();
+            if (age > maxAge) {
+                staleIndices.push(index);
+            }
+        }
+        return staleIndices;
+    }
+    /**
+     * Gets the most frequently accessed elements
+     */
+    getMostAccessedElements(limit = 10) {
+        const elements = Array.from(this.metadata.entries())
+            .map(([index, metadata]) => ({
+            index,
+            accessCount: metadata.accessCount,
+        }))
+            .sort((a, b) => b.accessCount - a.accessCount)
+            .slice(0, limit);
+        return elements;
+    }
+    /**
+     * Gets elements by type
+     */
+    getElementsByType(type) {
+        const indices = [];
+        for (const [index, metadata] of this.metadata.entries()) {
+            if (metadata.type === type) {
+                indices.push(index);
+            }
+        }
+        return indices;
+    }
+    /**
+     * Validates metadata integrity
+     */
+    validateIntegrity() {
+        const errors = [];
+        const warnings = [];
+        // Check for negative indices
+        for (const index of this.metadata.keys()) {
+            if (index < 0) {
+                errors.push(`Invalid negative index: ${index}`);
+            }
+        }
+        // Check for metadata consistency
+        for (const [index, metadata] of this.metadata.entries()) {
+            if (metadata.index !== index) {
+                errors.push(`Index mismatch: metadata.index=${metadata.index}, key=${index}`);
+            }
+            if (metadata.accessCount < 0) {
+                errors.push(`Invalid access count: ${metadata.accessCount} at index ${index}`);
+            }
+            if (metadata.created > new Date()) {
+                warnings.push(`Future creation date at index ${index}`);
+            }
+            if (metadata.lastAccessed < metadata.created) {
+                warnings.push(`Last accessed before creation at index ${index}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Exports metadata to a serializable format
+     */
+    export() {
+        return Array.from(this.metadata.entries());
+    }
+    /**
+     * Imports metadata from a serializable format
+     */
+    import(data) {
+        this.metadata.clear();
+        for (const [index, metadata] of data) {
+            this.metadata.set(index, {
+                ...metadata,
+                created: new Date(metadata.created),
+                lastAccessed: new Date(metadata.lastAccessed),
+            });
+        }
+    }
+    /**
+     * Gets the size of the metadata map
+     */
+    size() {
+        return this.metadata.size;
+    }
+    /**
+     * Gets all metadata (alias for getAll)
+     */
+    getAllMetadata() {
+        return this.getAll();
+    }
+    /**
+     * Handles splice operations on metadata
+     */
+    splice(start, deleteCount, insertCount) {
+        const newMetadata = new Map();
+        // Copy metadata before the splice point
+        for (const [index, metadata] of this.metadata.entries()) {
+            if (index < start) {
+                newMetadata.set(index, metadata);
+            }
+            else if (index >= start + deleteCount) {
+                // Shift indices after the splice point
+                const newIndex = index - deleteCount + insertCount;
+                metadata.index = newIndex;
+                newMetadata.set(newIndex, metadata);
+            }
+            // Skip metadata in the deleted range
+        }
+        this.metadata = newMetadata;
+    }
+    /**
+     * Reverses the metadata indices
+     */
+    reverse(length) {
+        const newMetadata = new Map();
+        for (const [index, metadata] of this.metadata.entries()) {
+            const newIndex = length - 1 - index;
+            metadata.index = newIndex;
+            newMetadata.set(newIndex, metadata);
+        }
+        this.metadata = newMetadata;
+    }
+    /**
+     * Reorders metadata based on new index mapping
+     */
+    reorder(newIndices) {
+        const newMetadata = new Map();
+        for (let i = 0; i < newIndices.length; i++) {
+            const oldIndex = newIndices[i];
+            const metadata = this.metadata.get(oldIndex);
+            if (metadata) {
+                metadata.index = i;
+                newMetadata.set(i, metadata);
+            }
+        }
+        this.metadata = newMetadata;
+    }
+}
+
+exports.ArrayMetadataManager = ArrayMetadataManager;
+//# sourceMappingURL=metadata-manager.js.map