@obinexusmk2/hypernum 0.1.0

package/src/config/config-loader.ts

@@ -0,0 +1,226 @@
+
+/**
+ * src/config/config-loader.ts
+ * Responsible for finding and loading configuration files
+ */
+
+import { HypernumConfig, mergeConfig } from "@/core";
+import path from "path";
+import { ConfigParser } from "./config-parser";
+import { ConfigSource } from "./config-source";
+import fs from 'fs';
+
+
+export interface ConfigSearchOptions {
+  /**
+   * Whether to search in parent directories
+   */
+  searchParentDirs?: boolean;
+  
+  /**
+   * Additional paths to search
+   */
+  additionalPaths?: string[];
+  
+  /**
+   * Base directory to start searching from
+   */
+  baseDir?: string;
+}
+
+export class ConfigLoader {
+  private readonly DEFAULT_CONFIG_FILES = [
+    '.hypernumrc',
+    '.hypernumrc.json',
+    '.hypernumrc.js',
+    'hypernum.config.js',
+    'hypernum.config.json',
+  ];
+  
+  private readonly DEFAULT_CONFIG_PATHS = [
+    process.cwd(),
+    path.join(process.cwd(), 'config'),
+    path.resolve(process.env['HOME'] || process.env['USERPROFILE'] || '', '.hypernum')
+  ];
+  
+  private configParser: ConfigParser;
+  private cachedConfig: HypernumConfig | null = null;
+  
+  constructor() {
+    this.configParser = new ConfigParser();
+  }
+  
+  /**
+   * Finds configuration files in standard locations
+   */
+  public findConfigFiles(options: ConfigSearchOptions = {}): Map<ConfigSource, string> {
+    const {
+      searchParentDirs = true,
+      additionalPaths = [],
+      baseDir = process.cwd()
+    } = options;
+    
+    const searchPaths = [
+      ...this.DEFAULT_CONFIG_PATHS,
+      ...additionalPaths
+    ];
+    
+    const configFiles = new Map<ConfigSource, string>();
+    
+    // Search for configuration files
+    for (const searchPath of searchPaths) {
+      for (const filename of this.DEFAULT_CONFIG_FILES) {
+        const filePath = path.join(searchPath, filename);
+        
+        if (fs.existsSync(filePath)) {
+          const source = this.getConfigSourceFromFilename(filename);
+          configFiles.set(source, filePath);
+        }
+      }
+    }
+    
+    // Search parent directories if enabled
+    if (searchParentDirs && baseDir !== path.parse(baseDir).root) {
+      let currentDir = baseDir;
+      let parentDir = path.dirname(currentDir);
+      
+      while (currentDir !== parentDir) {
+        for (const filename of this.DEFAULT_CONFIG_FILES) {
+          const filePath = path.join(currentDir, filename);
+          
+          if (fs.existsSync(filePath)) {
+            const source = this.getConfigSourceFromFilename(filename);
+            configFiles.set(source, filePath);
+          }
+        }
+        
+        currentDir = parentDir;
+        parentDir = path.dirname(currentDir);
+      }
+    }
+    
+    return configFiles;
+  }
+  
+  /**
+   * Determines the config source type from filename
+   */
+  public getConfigSourceFromFilename(filename: string): ConfigSource {
+    if (filename.endsWith('.js')) {
+      return ConfigSource.JS_FILE;
+    } else if (filename.endsWith('.json')) {
+      return ConfigSource.JSON_FILE;
+    } else if (filename.startsWith('.hypernumrc')) {
+      return ConfigSource.RC_FILE;
+    }
+    
+    return ConfigSource.JSON_FILE; // Default fallback
+  }
+ 
+  /**
+   * Loads configuration from a file
+   */
+  public loadConfigFromFile(filePath: string): Partial<HypernumConfig> {
+    try {
+      const extension = path.extname(filePath);
+      
+      switch (extension) {
+        case '.js':
+          return this.configParser.parseJsConfig(filePath);
+        case '.json':
+          return this.configParser.parseJsonConfig(filePath);
+        default:
+          if (filePath.includes('.hypernumrc')) {
+            return this.configParser.parseRcConfig(filePath);
+          }
+          throw new Error(`Unsupported config file extension: ${extension}`);
+      }
+    } catch (error) {
+      console.error(`Error loading config from ${filePath}:`, error);
+      return {};
+    }
+  }
+  
+  /**
+   * Loads configuration from all available sources
+   */
+  public loadConfig(options: ConfigSearchOptions = {}): HypernumConfig {
+    // Return cached config if available
+    if (this.cachedConfig) {
+      return this.cachedConfig;
+    }
+    
+    const configFiles = this.findConfigFiles(options);
+    const configs: Partial<HypernumConfig>[] = [];
+    
+    // Load environment variables first (highest priority)
+    const envConfig = this.loadEnvConfig();
+    if (Object.keys(envConfig).length > 0) {
+      configs.push(envConfig);
+    }
+    
+    // Load from config files in order of priority
+    for (const source of [ConfigSource.RC_FILE, ConfigSource.JSON_FILE, ConfigSource.JS_FILE]) {
+      const filePath = configFiles.get(source);
+      if (filePath) {
+        const fileConfig = this.loadConfigFromFile(filePath);
+        configs.push(fileConfig);
+      }
+    }
+    
+    // Merge configurations with default config as base
+    let finalConfig = {} as HypernumConfig;
+    for (const config of configs.reverse()) {
+      finalConfig = mergeConfig({ ...finalConfig, ...config });
+    }
+    
+    // Cache the configuration
+    this.cachedConfig = finalConfig;
+    return finalConfig;
+  }
+  
+  /**
+   * Loads environment variables as configuration
+   */
+  public loadEnvConfig(): Partial<HypernumConfig> {
+    const envConfig: Partial<HypernumConfig> = {};
+    // Load environment variables here and populate envConfig
+    // Example: envConfig.someKey = process.env.SOME_ENV_VAR;
+    return envConfig;
+  }
+
+  
+  /**
+   * Saves configuration to a file
+   */
+  public saveConfig(config: HypernumConfig, filePath: string): void {
+    try {
+      const extension = path.extname(filePath);
+      
+      switch (extension) {
+        case '.js':
+          const jsContent = `module.exports = ${this.configParser.stringifyConfig(config)};`;
+          fs.writeFileSync(filePath, jsContent, 'utf-8');
+          break;
+        case '.json':
+          fs.writeFileSync(filePath, this.configParser.stringifyConfig(config), 'utf-8');
+          break;
+        default:
+          if (filePath.includes('.hypernumrc')) {
+            fs.writeFileSync(filePath, this.configParser.stringifyConfig(config), 'utf-8');
+          } else {
+            throw new Error(`Unsupported config file extension: ${extension}`);
+          }
+      }
+    } catch (error) {
+      console.error(`Error saving config to ${filePath}:`, error);
+    }
+  }
+  
+  /**
+   * Clears the configuration cache
+   */
+  public clearCache(): void {
+    this.cachedConfig = null;
+  }
+}

package/src/config/config-parser.ts

@@ -0,0 +1,161 @@
+
+
+/**
+ * src/config/config-parser.ts
+ * Parses configuration files in different formats
+ */
+
+import { HypernumConfig } from "@/core";
+import path from "path";
+import fs from 'fs';
+
+
+export class ConfigParser {
+  /**
+   * Parses a JSON configuration file
+   */
+  public parseJsonConfig(filePath: string): Partial<HypernumConfig> {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content) as Partial<HypernumConfig>;
+    } catch (error) {
+      console.error(`Error parsing JSON config file ${filePath}:`, error);
+      return {};
+    }
+  }
+  
+  /**
+   * Parses a JavaScript configuration file
+   */
+  public parseJsConfig(filePath: string): Partial<HypernumConfig> {
+    try {
+      // Use dynamic import for ESM compatibility
+      if (path.isAbsolute(filePath)) {
+        // For Node.js environments
+        const config = require(filePath);
+        return config.default || config;
+      } else {
+        // For browser environments or when relative path is used
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        const config = require(absolutePath);
+        return config.default || config;
+      }
+    } catch (error) {
+      console.error(`Error parsing JS config file ${filePath}:`, error);
+      return {};
+    }
+  }
+  
+  /**
+   * Parses an RC configuration file
+   */
+  public parseRcConfig(filePath: string): Partial<HypernumConfig> {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      
+      // Try to parse as JSON first
+      try {
+        return JSON.parse(content) as Partial<HypernumConfig>;
+      } catch {
+        // Not valid JSON, try to parse as JS if it has JS-like syntax
+        if (content.includes('module.exports') || content.includes('export default')) {
+          // Create a temporary JS file to require
+          const tempFilePath = `${filePath}.temp.js`;
+          fs.writeFileSync(tempFilePath, content);
+          
+          try {
+            const config = require(tempFilePath);
+            fs.unlinkSync(tempFilePath); // Clean up temp file
+            return config.default || config;
+          } catch (jsError) {
+            fs.unlinkSync(tempFilePath); // Clean up temp file even on error
+            throw jsError;
+          }
+        }
+        
+        // Handle INI-style RC files
+        return this.parseIniStyleConfig(content);
+      }
+    } catch (error) {
+      console.error(`Error parsing RC config file ${filePath}:`, error);
+      return {};
+    }
+  }
+  
+  /**
+   * Parses an INI-style configuration
+   */
+  private parseIniStyleConfig(content: string): Partial<HypernumConfig> {
+    const config: Record<string, any> = {};
+    let currentSection = '';
+    
+    const lines = content.split('\n');
+    
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      
+      // Skip comments and empty lines
+      if (trimmedLine.startsWith('#') || trimmedLine.startsWith(';') || !trimmedLine) {
+        continue;
+      }
+      
+      // Section header
+      const sectionMatch = trimmedLine.match(/^\[([^\]]+)\]$/);
+      if (sectionMatch) {
+        if (sectionMatch[1]) {
+          currentSection = sectionMatch[1];
+          if (!config[currentSection]) {
+            config[currentSection] = {};
+          }
+          continue;
+        }
+      }
+      
+      // Key-value pair
+      const keyValueMatch = trimmedLine.match(/^([^=]+)=(.*)$/);
+      if (keyValueMatch) {
+        const key = keyValueMatch[1]?.trim() || '';
+        let value: any = keyValueMatch[2] ? keyValueMatch[2].trim() : '';
+        
+        // Try to parse the value
+        if (value === 'true' || value === 'false') {
+          value = value === 'true';
+        } else if (!isNaN(Number(value))) {
+          value = Number(value);
+        } else if (value.startsWith('"') && value.endsWith('"')) {
+          value = value.slice(1, -1);
+        } else if (value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        
+        if (currentSection) {
+          config[currentSection][key] = value;
+        } else {
+          config[key] = value;
+        }
+      }
+    }
+    
+    return config as Partial<HypernumConfig>;
+  }
+  
+  /**
+   * Stringifies a configuration object for saving
+   */
+  public stringifyConfig(config: HypernumConfig): string {
+    // Use a custom replacer function to handle BigInt and circular references
+    const seen = new WeakSet();
+    return JSON.stringify(config, (_, value) => {
+      if (typeof value === 'bigint') {
+        return value.toString() + 'n';
+      }
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+          return '[Circular]';
+        }
+        seen.add(value);
+      }
+      return value;
+    }, 2);
+  }
+}

package/src/config/config-resolver.ts

@@ -0,0 +1,52 @@
+/**
+ * src/config/config-resolver.ts
+ * Resolves configuration from multiple sources
+ */
+import { HypernumConfig, mergeConfig } from '../core/config';
+import { ConfigSource } from './config-source';
+
+export class ConfigResolver {
+  /**
+   * Default precedence order for configuration sources
+   */
+  private readonly DEFAULT_PRECEDENCE: ConfigSource[] = [
+    ConfigSource.INLINE_CONFIG,    // Highest priority
+    ConfigSource.ENV_VARIABLES,
+    ConfigSource.RC_FILE,
+    ConfigSource.JSON_FILE,
+    ConfigSource.JS_FILE           // Lowest priority
+  ];
+  
+  /**
+   * Resolves configuration from multiple sources
+   */
+  public resolveConfig(configs: Map<ConfigSource, Partial<HypernumConfig>>): HypernumConfig {
+    // Sort configurations by precedence
+    const sortedEntries = Array.from(configs.entries())
+      .sort((a, b) => {
+        const indexA = this.DEFAULT_PRECEDENCE.indexOf(a[0]);
+        const indexB = this.DEFAULT_PRECEDENCE.indexOf(b[0]);
+        return indexA - indexB;
+      });
+    
+    // Merge configurations in order (low to high priority)
+    let finalConfig = {} as HypernumConfig;
+    for (const [_, config] of sortedEntries) {
+      finalConfig = mergeConfig({ ...finalConfig, ...config });
+    }
+    
+    return finalConfig;
+  }
+  
+  /**
+   * Validates a configuration source
+   */
+  public validateConfigSource(config: Partial<HypernumConfig>): boolean {
+    // Basic validation for now - can be extended with schema validation
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+    
+    return true;
+  }
+}

package/src/config/config-source.ts

@@ -0,0 +1,32 @@
+/**
+ * src/config/config-source.ts
+ * Enum defining possible configuration sources
+ */
+export enum ConfigSource {
+    /**
+     * Environment variables with HYPERNUM_ prefix
+     */
+    ENV_VARIABLES = 'ENV_VARIABLES',
+    
+    /**
+     * RC file (.hypernumrc, .hypernumrc.json, etc.)
+     */
+    RC_FILE = 'RC_FILE',
+    
+    /**
+     * JSON configuration file (hypernum.config.json)
+     */
+    JSON_FILE = 'JSON_FILE',
+    
+    /**
+     * JavaScript configuration file (hypernum.config.js)
+     */
+    JS_FILE = 'JS_FILE',
+    
+    /**
+     * Inline configuration passed to createHypernum()
+     */
+    INLINE_CONFIG = 'INLINE_CONFIG'
+  }
+
+  

package/src/config/index.ts

@@ -0,0 +1,159 @@
+/**
+ * src/config/index.ts
+ * Main configuration module
+ */
+import { HypernumConfig,DEFAULT_BASIC_CONFIG, DEFAULT_FULL_CONFIG } from '../core/config';
+import { ConfigLoader } from './config-loader';
+import { ConfigParser } from './config-parser';
+import { ConfigResolver } from './config-resolver';
+import { ConfigSource } from './config-source';
+
+interface ConfigurationOptions {
+  /**
+   * Path to a configuration file to use
+   */
+  configFile?: string;
+  
+  /**
+   * Whether to search for configuration files in parent directories
+   */
+  searchParentDirs?: boolean;
+  
+  /**
+   * Additional paths to search for configuration files
+   */
+  additionalSearchPaths?: string[];
+  
+  /**
+   * Whether to use environment variables
+   */
+  useEnvVars?: boolean;
+  
+  /**
+   * Whether to cache the configuration
+   */
+  cacheConfig?: boolean;
+  
+  /**
+   * Inline configuration to use as a base
+   */
+  baseConfig?: Partial<HypernumConfig>;
+}
+
+/**
+ * Main configuration module for Hypernum
+ */
+export class ConfigurationModule {
+  public configLoader: ConfigLoader;
+  public configParser: ConfigParser;
+  public configResolver: ConfigResolver;
+  public cachedConfig: HypernumConfig | null = null;
+  
+  constructor() {
+    this.configLoader = new ConfigLoader();
+    this.configParser = new ConfigParser();
+    this.configResolver = new ConfigResolver();
+  }
+  
+  /**
+   * Gets the configuration, loading from all available sources
+   */
+  public getConfig(options: ConfigurationOptions = {}): HypernumConfig {
+    const {
+      configFile,
+      searchParentDirs = true,
+      additionalSearchPaths = [],
+      useEnvVars = true,
+      cacheConfig = true,
+      baseConfig = {}
+    } = options;
+    
+    // Return cached config if available and caching is enabled
+    if (this.cachedConfig && cacheConfig) {
+      return this.cachedConfig;
+    }
+    
+    const configs = new Map<ConfigSource, Partial<HypernumConfig>>();
+    
+    // Add base config (lowest priority)
+    if (Object.keys(baseConfig).length > 0) {
+      configs.set(ConfigSource.INLINE_CONFIG, baseConfig);
+    }
+    
+    // Load from specific file if provided
+    if (configFile) {
+      const fileConfig = this.configLoader.loadConfigFromFile(configFile);
+      const source = this.configLoader.getConfigSourceFromFilename(configFile);
+      if (this.configResolver.validateConfigSource(fileConfig)) {
+        configs.set(source, fileConfig);
+      }
+    } else {
+      // Search for configuration files
+      const configFiles = this.configLoader.findConfigFiles({
+        searchParentDirs,
+        additionalPaths: additionalSearchPaths
+      });
+      
+      for (const [source, filePath] of configFiles.entries()) {
+        const fileConfig = this.configLoader.loadConfigFromFile(filePath);
+        if (this.configResolver.validateConfigSource(fileConfig)) {
+          configs.set(source, fileConfig);
+        }
+      }
+    }
+    
+    // Load environment variables if enabled
+    if (useEnvVars) {
+      const envConfig = this.configLoader.loadEnvConfig();
+      if (Object.keys(envConfig).length > 0) {
+        configs.set(ConfigSource.ENV_VARIABLES, envConfig);
+      }
+    }
+    
+    // Resolve the final configuration
+    const finalConfig = this.configResolver.resolveConfig(configs);
+    
+    // Cache the configuration if caching is enabled
+    if (cacheConfig) {
+      this.cachedConfig = finalConfig;
+    }
+    
+    return finalConfig;
+  }
+  
+  /**
+   * Initializes configuration from a file
+   */
+  public initializeFromFile(filePath: string, options: ConfigurationOptions = {}): HypernumConfig {
+    return this.getConfig({
+      ...options,
+      configFile: filePath
+    });
+  }
+  
+  /**
+   * Creates a default configuration
+   */
+  public createDefaultConfig(type: 'basic' | 'full'): HypernumConfig {
+    return type === 'basic' ? DEFAULT_BASIC_CONFIG : DEFAULT_FULL_CONFIG;
+  }
+  
+  /**
+   * Saves configuration to a file
+   */
+  public saveConfigToFile(config: HypernumConfig, filePath: string): void {
+    this.configLoader.saveConfig(config, filePath);
+  }
+  
+  public getConfigSourceFromFilename(filename: string): ConfigSource {
+    return this.configLoader.getConfigSourceFromFilename(filename);
+  }
+
+  /**
+   * Clears the configuration cache
+   */
+  public clearCache(): void {
+    this.cachedConfig = null;
+    this.configLoader.clearCache();
+  }
+}