@unispechq/unispec-core 0.3.2 → 0.3.3

package/dist/cjs/cache/cache-manager.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniSpecCacheManager = void 0;
-const constants_1 = require("./constants.js");
-const lru_cache_1 = require("./lru-cache.js");
-/**
- * Cache manager for UniSpec operations.
- */
-class UniSpecCacheManager {
-    constructor(options = {}) {
-        this.cleanupInterval = null;
-        this.validationCache = new lru_cache_1.LRUCache({
-            ...options,
-            maxSize: constants_1.CACHE_CONSTANTS.VALIDATION_MAX_SIZE,
-        });
-        this.normalizationCache = new lru_cache_1.LRUCache({
-            ...options,
-            maxSize: constants_1.CACHE_CONSTANTS.NORMALIZATION_MAX_SIZE,
-        });
-        this.diffCache = new lru_cache_1.LRUCache({
-            ...options,
-            maxSize: constants_1.CACHE_CONSTANTS.DIFF_MAX_SIZE,
-        });
-        // Start cleanup interval
-        this.startCleanup();
-    }
-    /**
-     * Get cached validation result asynchronously.
-     */
-    async getValidationResult(documentHash) {
-        return await this.validationCache.get(documentHash);
-    }
-    /**
-     * Cache validation result asynchronously.
-     */
-    async setValidationResult(documentHash, result) {
-        await this.validationCache.set(documentHash, result);
-    }
-    /**
-     * Get cached normalization result asynchronously.
-     */
-    async getNormalizationResult(documentHash) {
-        return await this.normalizationCache.get(documentHash);
-    }
-    /**
-     * Cache normalization result asynchronously.
-     */
-    async setNormalizationResult(documentHash, result) {
-        await this.normalizationCache.set(documentHash, result);
-    }
-    /**
-     * Get cached diff result asynchronously.
-     */
-    async getDiffResult(docsHash) {
-        return await this.diffCache.get(docsHash);
-    }
-    /**
-     * Cache diff result asynchronously.
-     */
-    async setDiffResult(docsHash, result) {
-        await this.diffCache.set(docsHash, result);
-    }
-    /**
-     * Get comprehensive cache statistics.
-     */
-    getStats() {
-        const validationStats = this.validationCache.getStats();
-        const normalizationStats = this.normalizationCache.getStats();
-        const diffStats = this.diffCache.getStats();
-        const total = {
-            size: validationStats.size + normalizationStats.size + diffStats.size,
-            hits: validationStats.hits + normalizationStats.hits + diffStats.hits,
-            misses: validationStats.misses + normalizationStats.misses + diffStats.misses,
-            hitRate: 0,
-        };
-        const totalRequests = total.hits + total.misses;
-        total.hitRate = totalRequests > 0 ? total.hits / totalRequests : 0;
-        return {
-            validation: validationStats,
-            normalization: normalizationStats,
-            diff: diffStats,
-            total,
-        };
-    }
-    /**
-     * Clear all caches.
-     */
-    clearAll() {
-        this.validationCache.clear();
-        this.normalizationCache.clear();
-        this.diffCache.clear();
-    }
-    /**
-     * Start automatic cleanup interval.
-     */
-    startCleanup() {
-        try {
-            this.cleanupInterval = setInterval(() => {
-                try {
-                    this.validationCache.cleanup();
-                    this.normalizationCache.cleanup();
-                    this.diffCache.cleanup();
-                }
-                catch (error) {
-                    console.error(constants_1.CACHE_MESSAGES.CLEANUP_ERROR, error);
-                    // Continue running cleanup even if one cache fails
-                }
-            }, constants_1.CACHE_CONSTANTS.CLEANUP_INTERVAL);
-        }
-        catch (error) {
-            console.error(constants_1.CACHE_MESSAGES.CLEANUP_START_ERROR, error);
-            // Cache will still work without automatic cleanup
-        }
-    }
-    /**
-     * Stop automatic cleanup.
-     */
-    destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        this.clearAll();
-    }
-}
-exports.UniSpecCacheManager = UniSpecCacheManager;

package/dist/cjs/cache/constants.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * Cache configuration constants.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CACHE_MESSAGES = exports.CACHE_CONSTANTS = void 0;
-exports.CACHE_CONSTANTS = {
-    // Default cache sizes
-    DEFAULT_MAX_SIZE: 100,
-    VALIDATION_MAX_SIZE: 50,
-    NORMALIZATION_MAX_SIZE: 30,
-    DIFF_MAX_SIZE: 20,
-    // TTL values (in milliseconds)
-    DEFAULT_TTL: 5 * 60 * 1000, // 5 minutes
-    CLEANUP_INTERVAL: 60000, // 1 minute
-    // Hash configuration
-    HASH_GOLDEN_RATIO: 2654435761,
-    HASH_BASE: 31,
-    HASH_MASK: 0xffffffff,
-};
-exports.CACHE_MESSAGES = {
-    CLEANUP_ERROR: "Cache cleanup error",
-    CLEANUP_START_ERROR: "Failed to start cleanup interval",
-    CACHE_WILL_CONTINUE: "Cache will still work without automatic cleanup",
-};

package/dist/cjs/cache/hash-utils.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDocumentHash = generateDocumentHash;
-exports.generateDocumentHashSync = generateDocumentHashSync;
-exports.generateDiffHash = generateDiffHash;
-exports.generateDiffHashSync = generateDiffHashSync;
-const hashing_1 = require("./hashing.js");
-/**
- * Generate a hash for a UniSpec document for caching purposes.
- * Uses optimized hashing for better performance and collision resistance.
- */
-async function generateDocumentHash(document) {
-    return await (0, hashing_1.generateOptimizedDocumentHash)(document);
-}
-/**
- * Synchronous version for backward compatibility (deprecated).
- * @deprecated Use async version for better security
- */
-function generateDocumentHashSync(document) {
-    // Fallback to old method for backward compatibility
-    console.warn("generateDocumentHashSync is deprecated. Use async generateDocumentHash for better security.");
-    const str = JSON.stringify(document, Object.keys(document).sort());
-    return (0, hashing_1.simpleHash)(str);
-}
-/**
- * Generate a hash for two documents (for diff caching).
- * Uses optimized diff hashing with better collision resistance.
- */
-async function generateDiffHash(oldDoc, newDoc) {
-    return await (0, hashing_1.generateOptimizedDiffHash)(oldDoc, newDoc);
-}
-/**
- * Synchronous version for backward compatibility (deprecated).
- * @deprecated Use async version for better security
- */
-function generateDiffHashSync(oldDoc, newDoc) {
-    console.warn("generateDiffHashSync is deprecated. Use async generateDiffHash for better security.");
-    const oldStr = JSON.stringify(oldDoc, Object.keys(oldDoc).sort());
-    const newStr = JSON.stringify(newDoc, Object.keys(newDoc).sort());
-    return (0, hashing_1.simpleHash)(`${oldStr}:${newStr}`);
-}

package/dist/cjs/cache/hashing.js

@@ -1,236 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateOptimizedDocumentHash = generateOptimizedDocumentHash;
-exports.generateOptimizedDiffHash = generateOptimizedDiffHash;
-exports.simpleHash = simpleHash;
-exports.fnv1aHash = fnv1aHash;
-const constants_1 = require("../cache/constants.js");
-/**
- * Secure document hashing utilities using Web Crypto API.
- */
-/**
- * Secure hash using Web Crypto API (SHA-256) or Node.js crypto.
- * Fallback to FNV-1a only if both crypto APIs are unavailable.
- */
-async function secureHash(str) {
-    // Try Web Crypto API first (browser environments)
-    if (typeof crypto !== "undefined" && crypto.subtle) {
-        try {
-            const encoder = new TextEncoder();
-            const data = encoder.encode(str);
-            const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-            const hashArray = Array.from(new Uint8Array(hashBuffer));
-            return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-        }
-        catch (error) {
-            console.warn("Web Crypto API failed, trying Node.js crypto:", error);
-        }
-    }
-    // Try Node.js crypto API (server environments)
-    try {
-        // Dynamic import for Node.js crypto to avoid browser compatibility issues
-        const crypto = await Promise.resolve().then(() => __importStar(require("node:crypto")));
-        const hash = crypto.createHash("sha256");
-        hash.update(str, "utf8");
-        return hash.digest("hex");
-    }
-    catch (error) {
-        console.warn("Node.js crypto API failed, falling back to FNV-1a:", error);
-    }
-    // Last resort: FNV-1a algorithm (non-cryptographic, for compatibility only)
-    console.warn("Using FNV-1a fallback hash - consider installing crypto support");
-    return fnv1aHashFallback(str).toString();
-}
-/**
- * FNV-1a fallback hash function (non-cryptographic, for compatibility).
- */
-function fnv1aHashFallback(str) {
-    let hash = 2166136261; // FNV offset basis
-    for (let i = 0; i < str.length; i++) {
-        hash ^= str.charCodeAt(i);
-        hash = (hash * 16777619) & constants_1.CACHE_CONSTANTS.HASH_MASK; // FNV prime
-    }
-    return hash;
-}
-/**
- * Generate a secure hash for a document using optimized sorting and Web Crypto API.
- */
-async function generateOptimizedDocumentHash(document) {
-    // Use optimized stable stringification
-    const str = stableStringify(document);
-    // Use secure hash for better distribution and collision resistance
-    const hash = await secureHash(str);
-    // Add length and type prefix for additional collision resistance
-    const typePrefix = getDocumentTypePrefix(document);
-    const combined = `${hash}_${str.length}_${typePrefix}`;
-    // Create final hash with combined string
-    const finalHash = await secureHash(combined);
-    return `${finalHash.slice(0, 16)}_${str.length}`;
-}
-/**
- * Default configuration for stable stringification.
- */
-const DEFAULT_STRINGIFY_CONFIG = {
-    maxDepth: 100,
-    maxKeys: 10000,
-    handleCircular: true,
-    handleDeepObjects: true,
-};
-/**
- * Optimized stable stringification that avoids recursion depth issues.
- */
-function stableStringify(obj, config = {}, depth = 0, visited = new WeakSet()) {
-    const finalConfig = { ...DEFAULT_STRINGIFY_CONFIG, ...config };
-    // Prevent infinite recursion
-    if (depth > finalConfig.maxDepth) {
-        return `"[MAX_DEPTH_REACHED:${depth}]"`;
-    }
-    // Handle circular references
-    if (finalConfig.handleCircular && obj && typeof obj === "object") {
-        if (visited.has(obj)) {
-            return `"[CIRCULAR_REFERENCE:${obj.constructor?.name || "Object"}]"`;
-        }
-        visited.add(obj);
-    }
-    // Handle primitives
-    if (obj === null || typeof obj !== "object") {
-        return JSON.stringify(obj);
-    }
-    // Handle special object types
-    if (obj instanceof Date) {
-        return obj.toISOString();
-    }
-    if (obj instanceof RegExp) {
-        return `"[REGEX:${obj.toString()}]"`;
-    }
-    if (obj instanceof Error) {
-        return `"[ERROR:${obj.name}:${obj.message}]"`;
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(obj)) {
-        return `"[BUFFER:${obj.toString("base64")}]"`;
-    }
-    // Handle Array
-    if (Array.isArray(obj)) {
-        if (obj.length > finalConfig.maxKeys) {
-            return `"[ARRAY_TOO_LARGE:${obj.length}]"`;
-        }
-        const elements = obj.map((item, index) => {
-            try {
-                return stableStringify(item, finalConfig, depth + 1, visited);
-            }
-            catch (error) {
-                return `"[ERROR_AT_INDEX_${index}:${error instanceof Error ? error.message : String(error)}]"`;
-            }
-        });
-        return `[${elements.join(",")}]`;
-    }
-    // Handle Object
-    if (typeof obj === "object") {
-        const objRecord = obj;
-        const keys = Object.keys(objRecord);
-        if (keys.length > finalConfig.maxKeys) {
-            return `"[OBJECT_TOO_LARGE:${keys.length}]"`;
-        }
-        const sortedKeys = keys.sort();
-        const pairs = [];
-        for (const key of sortedKeys) {
-            try {
-                const value = stableStringify(objRecord[key], finalConfig, depth + 1, visited);
-                pairs.push(`"${key}":${value}`);
-            }
-            catch (error) {
-                pairs.push(`"${key}":"[ERROR:${error instanceof Error ? error.message : String(error)}]"`);
-            }
-        }
-        return `{${pairs.join(",")}}`;
-    }
-    return "{}";
-}
-/**
- * Get a numeric prefix based on document type to reduce collisions.
- */
-function getDocumentTypePrefix(document) {
-    if (!document || typeof document !== "object")
-        return 0;
-    const doc = document;
-    // Check for UniSpec document
-    if (doc.unispecVersion)
-        return 1;
-    if (doc.uniSpecTestsVersion)
-        return 2;
-    if (doc.version && doc.services)
-        return 3;
-    // Check for common patterns
-    if (Array.isArray(document))
-        return 4;
-    if (doc.$schema)
-        return 5;
-    if (doc.type)
-        return typeof doc.type === "string" ? doc.type.charCodeAt(0) || 6 : 6;
-    return 7;
-}
-/**
- * Generate a secure hash for two documents (for diff caching) with optimized collision resistance.
- */
-async function generateOptimizedDiffHash(oldDoc, newDoc) {
-    const oldHash = await generateOptimizedDocumentHash(oldDoc);
-    const newHash = await generateOptimizedDocumentHash(newDoc);
-    // Combine hashes using order-sensitive operation
-    const combined = `${oldHash}:${newHash}`;
-    // Hash the combined string to get final result
-    const finalHash = await secureHash(combined);
-    return `${finalHash.slice(0, 16)}_${oldHash.length}_${newHash.length}`;
-}
-/**
- * Simple hash for small objects (keys, strings) using built-in hash.
- * Kept for backward compatibility but consider using secureHash for new code.
- */
-function simpleHash(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash + char) & constants_1.CACHE_CONSTANTS.HASH_MASK;
-    }
-    return hash.toString(36);
-}
-/**
- * Legacy synchronous hash function (deprecated - use secureHash instead).
- * @deprecated Use secureHash for better security
- */
-function fnv1aHash(str) {
-    console.warn("fnv1aHash is deprecated. Use secureHash for better security.");
-    return fnv1aHashFallback(str);
-}

package/dist/cjs/cache/index.js

@@ -1,26 +0,0 @@
-"use strict";
-// Constants and messages
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRUCache = exports.generateDocumentHashSync = exports.generateDocumentHash = exports.generateDiffHashSync = exports.generateDiffHash = exports.CACHE_MESSAGES = exports.CACHE_CONSTANTS = exports.UniSpecCacheManager = exports.getManagersStats = exports.destroyManagers = exports.createNamedCacheManager = exports.createCacheManager = exports.clearTestRegistry = void 0;
-// Cache factory
-var cache_factory_1 = require("./cache-factory.js");
-Object.defineProperty(exports, "clearTestRegistry", { enumerable: true, get: function () { return cache_factory_1.clearTestRegistry; } });
-Object.defineProperty(exports, "createCacheManager", { enumerable: true, get: function () { return cache_factory_1.createCacheManager; } });
-Object.defineProperty(exports, "createNamedCacheManager", { enumerable: true, get: function () { return cache_factory_1.createNamedCacheManager; } });
-Object.defineProperty(exports, "destroyManagers", { enumerable: true, get: function () { return cache_factory_1.destroyManagers; } });
-Object.defineProperty(exports, "getManagersStats", { enumerable: true, get: function () { return cache_factory_1.getManagersStats; } });
-// Cache manager
-var cache_manager_1 = require("./cache-manager.js");
-Object.defineProperty(exports, "UniSpecCacheManager", { enumerable: true, get: function () { return cache_manager_1.UniSpecCacheManager; } });
-var constants_1 = require("./constants.js");
-Object.defineProperty(exports, "CACHE_CONSTANTS", { enumerable: true, get: function () { return constants_1.CACHE_CONSTANTS; } });
-Object.defineProperty(exports, "CACHE_MESSAGES", { enumerable: true, get: function () { return constants_1.CACHE_MESSAGES; } });
-// Hash utilities
-var hash_utils_1 = require("./hash-utils.js");
-Object.defineProperty(exports, "generateDiffHash", { enumerable: true, get: function () { return hash_utils_1.generateDiffHash; } });
-Object.defineProperty(exports, "generateDiffHashSync", { enumerable: true, get: function () { return hash_utils_1.generateDiffHashSync; } });
-Object.defineProperty(exports, "generateDocumentHash", { enumerable: true, get: function () { return hash_utils_1.generateDocumentHash; } });
-Object.defineProperty(exports, "generateDocumentHashSync", { enumerable: true, get: function () { return hash_utils_1.generateDocumentHashSync; } });
-// Core cache implementation
-var lru_cache_1 = require("./lru-cache.js");
-Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return lru_cache_1.LRUCache; } });

package/dist/cjs/cache/lru-cache.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRUCache = void 0;
-const constants_1 = require("./constants.js");
-/**
- * Simple LRU (Least Recently Used) cache implementation.
- */
-class LRUCache {
-    constructor(options = {}) {
-        this.cache = new Map();
-        this.maxSize = options.maxSize || constants_1.CACHE_CONSTANTS.DEFAULT_MAX_SIZE;
-        this.ttl = options.ttl || constants_1.CACHE_CONSTANTS.DEFAULT_TTL;
-        this.enableStats = options.enableStats || false;
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            size: 0,
-            hitRate: 0,
-            evictions: 0,
-        };
-    }
-    /**
-     * Get a value from the cache asynchronously.
-     * For performance, this uses sync operations wrapped in Promise for compatibility.
-     */
-    async get(key) {
-        // Use synchronous operations for better performance
-        // Only wrap in Promise for async interface compatibility
-        return Promise.resolve(this.getSync(key));
-    }
-    /**
-     * Set a value in the cache asynchronously.
-     * For performance, this uses sync operations wrapped in Promise for compatibility.
-     */
-    async set(key, value) {
-        // Use synchronous operations for better performance
-        // Only wrap in Promise for async interface compatibility
-        this.setSync(key, value);
-        return Promise.resolve();
-    }
-    /**
-     * Get a value from the cache (synchronous version for backward compatibility).
-     * @deprecated Use async get() method instead
-     */
-    getSync(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            if (this.enableStats) {
-                this.stats.misses++;
-                this.updateHitRate();
-            }
-            return undefined;
-        }
-        // Check TTL
-        if (this.isExpired(entry)) {
-            this.cache.delete(key);
-            if (this.enableStats) {
-                this.stats.misses++;
-                this.stats.size--;
-                this.updateHitRate();
-            }
-            return undefined;
-        }
-        // Update access info
-        entry.accessCount++;
-        entry.lastAccessed = Date.now();
-        // Move to end (most recently used)
-        this.cache.delete(key);
-        this.cache.set(key, entry);
-        if (this.enableStats) {
-            this.stats.hits++;
-            this.updateHitRate();
-        }
-        return entry.value;
-    }
-    /**
-     * Set a value in the cache (synchronous version for backward compatibility).
-     * @deprecated Use async set() method instead
-     */
-    setSync(key, value) {
-        // Remove existing entry if present
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-        // Evict oldest entries if cache is full
-        while (this.cache.size >= this.maxSize) {
-            const oldestKey = this.cache.keys().next().value;
-            if (oldestKey) {
-                this.cache.delete(oldestKey);
-                if (this.enableStats) {
-                    this.stats.evictions++;
-                    this.stats.size--;
-                }
-            }
-            else {
-                break;
-            }
-        }
-        const entry = {
-            value,
-            timestamp: Date.now(),
-            accessCount: 1,
-            lastAccessed: Date.now(),
-        };
-        this.cache.set(key, entry);
-        if (this.enableStats) {
-            this.stats.size++;
-        }
-    }
-    /**
-     * Delete a value from the cache.
-     */
-    delete(key) {
-        const deleted = this.cache.delete(key);
-        if (deleted && this.enableStats) {
-            this.stats.size--;
-        }
-        return deleted;
-    }
-    /**
-     * Clear all entries from the cache.
-     */
-    clear() {
-        this.cache.clear();
-        if (this.enableStats) {
-            this.stats.size = 0;
-        }
-    }
-    /**
-     * Get cache statistics.
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Check if an entry is expired.
-     */
-    isExpired(entry) {
-        return Date.now() - entry.timestamp > this.ttl;
-    }
-    /**
-     * Update hit rate statistics.
-     */
-    updateHitRate() {
-        const total = this.stats.hits + this.stats.misses;
-        this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
-    }
-    /**
-     * Clean up expired entries.
-     */
-    cleanup() {
-        let cleaned = 0;
-        for (const [key, entry] of this.cache.entries()) {
-            if (this.isExpired(entry)) {
-                this.cache.delete(key);
-                cleaned++;
-                if (this.enableStats) {
-                    this.stats.size--;
-                }
-            }
-        }
-        return cleaned;
-    }
-}
-exports.LRUCache = LRUCache;

package/dist/cjs/cache/types.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * Cache interfaces and types.
- */
-Object.defineProperty(exports, "__esModule", { value: true });