generalFunctions/datasets/assetData/curves/index.js

const fs = require('fs');
const path = require('path');

class AssetLoader {
  constructor(maxCacheSize = 100) {
    this.relPath = './'
    this.baseDir = path.resolve(__dirname, this.relPath);
    this.cache = new Map();
    this.maxCacheSize = maxCacheSize;
  }

  /**
   * Load a specific curve by type
   * @param {string} curveType - The curve identifier (e.g., 'hidrostal-H05K-S03R')
   * @returns {Object|null} The curve data object or null if not found
   */
  loadCurve(curveType) {
    return this.loadAsset('curves', curveType);
  }

  /**
   * Load any asset from a specific dataset folder
   * @param {string} datasetType - The dataset folder name (e.g., 'curves', 'assetData')
   * @param {string} assetId - The specific asset identifier
   * @returns {Object|null} The asset data object or null if not found
   */
  loadAsset(datasetType, assetId) {
    //const cacheKey = `${datasetType}/${assetId}`;
    const normalizedAssetId = String(assetId || '').trim();
    if (!normalizedAssetId) {
      return null;
    }
    const cacheKey = normalizedAssetId.toLowerCase();

    
    // Check cache first
    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey);
    }

    try {
      const filePath = this._resolveAssetPath(normalizedAssetId);

      // Check if file exists
      if (!filePath || !fs.existsSync(filePath)) {
        console.warn(`Asset not found for id '${normalizedAssetId}' in ${this.baseDir}`);
        return null;
      }

      // Load and parse JSON
      const rawData = fs.readFileSync(filePath, 'utf8');
      const assetData = JSON.parse(rawData);
      
      // Cache the result (evict oldest if at capacity)
      if (this.cache.size >= this.maxCacheSize) {
        const oldestKey = this.cache.keys().next().value;
        this.cache.delete(oldestKey);
      }
      this.cache.set(cacheKey, assetData);
      
      return assetData;
    } catch (error) {
      console.error(`Error loading asset ${cacheKey}:`, error.message);
      return null;
    }
  }

  _resolveAssetPath(assetId) {
    const exactPath = path.join(this.baseDir, `${assetId}.json`);
    if (fs.existsSync(exactPath)) {
      return exactPath;
    }

    const target = `${assetId}.json`.toLowerCase();
    const files = fs.readdirSync(this.baseDir);
    const matched = files.find((file) => file.toLowerCase() === target);
    if (!matched) {
      return null;
    }
    return path.join(this.baseDir, matched);
  }

  /**
   * Get all available assets in a dataset
   * @param {string} datasetType - The dataset folder name
   * @returns {string[]} Array of available asset IDs
   */
  getAvailableAssets(datasetType) {
    try {
      const datasetPath = path.join(this.baseDir, datasetType);
      
      if (!fs.existsSync(datasetPath)) {
        return [];
      }

      return fs.readdirSync(datasetPath)
        .filter(file => file.endsWith('.json'))
        .map(file => file.replace('.json', ''));
    } catch (error) {
      console.error(`Error reading dataset ${datasetType}:`, error.message);
      return [];
    }
  }

  /**
   * Clear the cache (useful for development/testing)
   */
  clearCache() {
    this.cache.clear();
  }
}

// Create and export a singleton instance
const assetLoader = new AssetLoader();

module.exports = {
  AssetLoader,
  assetLoader,
  // Convenience methods for backward compatibility
  loadCurve: (curveType) => assetLoader.loadCurve(curveType),
  loadAsset: (datasetType, assetId) => assetLoader.loadAsset(datasetType, assetId),
  getAvailableAssets: (datasetType) => assetLoader.getAvailableAssets(datasetType)
};

/*
// Example usage in your scripts
const loader = new AssetLoader();

// Load a specific curve
const curve = loader.loadCurve('hidrostal-H05K-S03R');
if (curve) {
  console.log('Curve loaded:', curve);
} else {
  console.log('Curve not found');
}
/*
// Load any asset from any dataset
const someAsset = loadAsset('assetData', 'some-asset-id');

// Get list of available curves
const availableCurves = getAvailableAssets('curves');
console.log('Available curves:', availableCurves);

// Using the class directly for more control
const { AssetLoader } = require('./index.js');
const customLoader = new AssetLoader();
const data = customLoader.loadCurve('hidrostal-H05K-S03R');
*/