@mdfriday/foundry 25.8.11 → 25.9.2

package/dist/internal/domain/template/vo/registry.js

@@ -137,6 +137,8 @@ class DefaultTemplateRegistry {
         this.registerFmtFunctions(funcMap);
         // Path functions
         this.registerPathFunctions(funcMap);
+        // Transform functions (unmarshal, etc.)
+        this.registerTransformFunctions(funcMap);
     }
     /**
      * Register cryptographic hash functions
@@ -367,6 +369,7 @@ class DefaultTemplateRegistry {
     registerResourcesFunctions(funcMap, services) {
         funcMap.set('resources', () => ({
             Get: async (filename) => await services.Get(filename),
+            GetRemote: async (uri) => await services.GetRemote(uri),
             Minify: async (resource) => await services.Minify(resource),
             Fingerprint: async (resource) => await services.Fingerprint(resource),
             ExecuteAsTemplate: async (targetPath, data, resource) => await services.ExecuteAsTemplate(targetPath, data, resource)
@@ -388,9 +391,43 @@ class DefaultTemplateRegistry {
      * Equivalent to Go's registerLang()
      */
     registerLanguageFunctions(funcMap, services) {
+        // Import language service
+        const { lang } = require('../../../../pkg/lang');
+        // Language namespace functions
+        funcMap.set('lang', () => ({
+            // Get all language codes
+            getAllCodes: () => lang.getAllCodes(),
+            // Get all language names
+            getAllNames: () => lang.getAllNames(),
+            // Get language codes by direction
+            getCodesByDirection: (direction) => lang.getCodesByDirection(direction),
+            // Get language names by direction
+            getNamesByDirection: (direction) => lang.getNamesByDirection(direction),
+            // Get code-name mapping
+            getCodeNameMap: () => lang.getCodeNameMap(),
+            // Get code-name mapping by direction
+            getCodeNameMapByDirection: (direction) => lang.getCodeNameMapByDirection(direction),
+            // Get language name by code
+            getNameByCode: (code) => lang.getNameByCode(code),
+            // Get language info by code
+            getLanguageInfo: (code) => lang.getLanguageInfo(code),
+            // Check if language is supported
+            isSupported: (code) => lang.isSupported(code),
+            // Get language direction
+            getDirection: (code) => lang.getDirection(code),
+            // Check if language is LTR
+            isLTR: (code) => lang.isLTR(code),
+            // Check if language is RTL
+            isRTL: (code) => lang.isRTL(code)
+        }));
+        // Standalone functions for convenience
+        funcMap.set('langName', (code) => lang.getNameByCode(code) || code);
+        funcMap.set('langDirection', (code) => lang.getDirection(code) || 'ltr');
+        funcMap.set('isLTR', (code) => lang.isLTR(code));
+        funcMap.set('isRTL', (code) => lang.isRTL(code));
+        // i18n placeholder (can be extended later)
         funcMap.set('i18n', (key) => {
-            // Placeholder for i18n functionality
-            return key;
+            return services.translate(key);
         });
     }
     /**
@@ -1281,6 +1318,43 @@ class DefaultTemplateRegistry {
             }
             return set1.filter(item => set2.includes(item));
         });
+        // querify function - converts key-value pairs to URL query string
+        // Usage: {{ querify "foo" 1 "bar" 2 "baz" "with spaces" }}
+        // Returns: bar=2&baz=with+spaces&foo=1
+        // Also supports array input: {{ slice "foo" 1 "bar" 2 | querify }}
+        funcMap.set('querify', (...args) => {
+            let params = [];
+            // Handle single array argument (from pipe)
+            if (args.length === 1 && Array.isArray(args[0])) {
+                params = args[0];
+            }
+            else {
+                params = args;
+            }
+            // Must have even number of parameters (key-value pairs)
+            if (params.length % 2 !== 0) {
+                throw new Error('querify requires an even number of arguments (key-value pairs)');
+            }
+            const queryParams = [];
+            // Process key-value pairs
+            for (let i = 0; i < params.length; i += 2) {
+                const key = String(params[i]);
+                const value = String(params[i + 1]);
+                queryParams.push([key, value]);
+            }
+            // Sort by key for consistent output (like Go's implementation)
+            queryParams.sort((a, b) => a[0].localeCompare(b[0]));
+            // Build query string
+            const queryString = queryParams
+                .map(([key, value]) => {
+                // URL encode key and value, replacing %20 with + for spaces (query string convention)
+                const encodedKey = encodeURIComponent(key).replace(/%20/g, '+');
+                const encodedValue = encodeURIComponent(value).replace(/%20/g, '+');
+                return `${encodedKey}=${encodedValue}`;
+            })
+                .join('&');
+            return queryString;
+        });
     }
     /**
      * Core indexing implementation following Go's doIndex logic
@@ -1560,15 +1634,6 @@ class DefaultTemplateRegistry {
         funcMap.set('slice', (...args) => {
             return args;
         });
-        // Printf function for string formatting
-        funcMap.set('printf', (format, ...args) => {
-            // Simple printf implementation
-            let result = format;
-            args.forEach((arg, index) => {
-                result = result.replace(new RegExp(`%[sdf]`, 'g'), String(arg));
-            });
-            return result;
-        });
         // Default function for providing default values
         // TypeScript equivalent of Go's default function
         funcMap.set('default', (defaultValue, value) => {
@@ -1641,11 +1706,32 @@ class DefaultTemplateRegistry {
     registerFmtFunctions(funcMap) {
         // Basic printf, print, println functions (for backward compatibility)
         funcMap.set('printf', (format, ...args) => {
-            // Simple printf implementation - you can enhance this with a proper sprintf library
+            // Enhanced printf implementation supporting %v, %s, %d, %f, %t
             let result = format;
-            for (let i = 0; i < args.length; i++) {
-                result = result.replace(/%[sd%]/, String(args[i]));
-            }
+            let argIndex = 0;
+            // Replace format specifiers sequentially
+            result = result.replace(/%[vsdft%]/g, (match) => {
+                if (match === '%%') {
+                    return '%'; // Literal %
+                }
+                if (argIndex >= args.length) {
+                    return match; // Not enough arguments, keep the format specifier
+                }
+                const arg = args[argIndex++];
+                switch (match) {
+                    case '%v': // Go's general format specifier
+                    case '%s': // String
+                        return String(arg);
+                    case '%d': // Integer
+                        return String(Math.floor(Number(arg) || 0));
+                    case '%f': // Float
+                        return String(Number(arg) || 0);
+                    case '%t': // Boolean
+                        return String(Boolean(arg));
+                    default:
+                        return String(arg);
+                }
+            });
             return result;
         });
         funcMap.set('print', (...args) => {
@@ -1884,6 +1970,306 @@ class DefaultTemplateRegistry {
             }
         }));
     }
+    /**
+     * Register transform functions (unmarshal, etc.)
+     * Equivalent to Go's transform package functions
+     */
+    registerTransformFunctions(funcMap) {
+        // Transform namespace functions - following Go's transform package
+        funcMap.set('transform', () => ({
+            // Unmarshal unmarshals data from JSON, YAML, TOML, CSV formats
+            // Usage: {{ $data := "{"key": "value"}" | transform.Unmarshal }}
+            // Usage: {{ $data := (dict "format" "json") $jsonString | transform.Unmarshal }}
+            Unmarshal: (...args) => {
+                if (args.length < 1 || args.length > 2) {
+                    throw new Error('unmarshal takes 1 or 2 arguments');
+                }
+                let data;
+                let options = {};
+                if (args.length === 1) {
+                    data = args[0];
+                }
+                else {
+                    // First argument is options map
+                    const opts = args[0];
+                    if (!opts || typeof opts !== 'object') {
+                        throw new Error('first argument must be a map');
+                    }
+                    options = opts;
+                    data = args[1];
+                }
+                // Handle Resource objects (if data has Content method)
+                if (data && typeof data === 'object' && typeof data.Content === 'function') {
+                    try {
+                        const content = data.Content();
+                        return this.unmarshalContent(content, options);
+                    }
+                    catch (error) {
+                        throw new Error(`failed to get content from resource: ${error.message}`);
+                    }
+                }
+                // Handle string data
+                let dataStr;
+                if (typeof data === 'string') {
+                    dataStr = data;
+                }
+                else if (data && typeof data.toString === 'function') {
+                    dataStr = data.toString();
+                }
+                else {
+                    throw new Error(`type ${typeof data} not supported`);
+                }
+                if (!dataStr || dataStr.trim() === '') {
+                    return null;
+                }
+                return this.unmarshalContent(dataStr, options);
+            }
+        }));
+        // Also register unmarshal as a standalone function for backward compatibility
+        funcMap.set('unmarshal', (...args) => {
+            const transform = funcMap.get('transform')();
+            return transform.Unmarshal(...args);
+        });
+    }
+    /**
+     * Unmarshal content from string based on format
+     * Supports JSON, YAML, TOML, CSV formats
+     */
+    unmarshalContent(content, options = {}) {
+        const trimmedContent = content.trim();
+        if (!trimmedContent) {
+            return null;
+        }
+        // Determine format
+        let format = options.format;
+        if (!format) {
+            format = this.detectFormat(trimmedContent);
+        }
+        try {
+            switch (format.toLowerCase()) {
+                case 'json':
+                    return JSON.parse(trimmedContent);
+                case 'yaml':
+                case 'yml':
+                    return this.parseYAML(trimmedContent);
+                case 'toml':
+                    return this.parseTOML(trimmedContent);
+                case 'csv':
+                    return this.parseCSV(trimmedContent);
+                default:
+                    throw new Error(`format "${format}" not supported`);
+            }
+        }
+        catch (error) {
+            throw new Error(`failed to unmarshal ${format}: ${error.message}`);
+        }
+    }
+    /**
+     * Detect format from content
+     */
+    detectFormat(content) {
+        const trimmed = content.trim();
+        // JSON detection
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+            (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            try {
+                JSON.parse(trimmed);
+                return 'json';
+            }
+            catch {
+                // Not valid JSON, continue checking
+            }
+        }
+        // YAML detection (starts with --- or has key: value patterns)
+        if (trimmed.startsWith('---') || /^[a-zA-Z_][a-zA-Z0-9_]*\s*:\s*.+/m.test(trimmed)) {
+            return 'yaml';
+        }
+        // TOML detection (has [section] or key = value patterns)
+        if (/^\[.*\]$/m.test(trimmed) || /^[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*.+/m.test(trimmed)) {
+            return 'toml';
+        }
+        // CSV detection (has comma-separated values)
+        if (/^[^,\n]*,[^,\n]*/.test(trimmed)) {
+            return 'csv';
+        }
+        // Default to JSON if uncertain
+        return 'json';
+    }
+    /**
+     * Parse YAML content (basic implementation)
+     * For a full implementation, you'd want to use a proper YAML library
+     */
+    parseYAML(content) {
+        // This is a very basic YAML parser for simple key-value pairs
+        // For production use, consider integrating a proper YAML library like js-yaml
+        const lines = content.split('\n');
+        const result = {};
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('#') || trimmedLine === '---') {
+                continue;
+            }
+            const colonIndex = trimmedLine.indexOf(':');
+            if (colonIndex > 0) {
+                const key = trimmedLine.substring(0, colonIndex).trim();
+                let value = trimmedLine.substring(colonIndex + 1).trim();
+                // Remove quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                // Try to parse as number or boolean
+                if (value === 'true') {
+                    result[key] = true;
+                }
+                else if (value === 'false') {
+                    result[key] = false;
+                }
+                else if (/^\d+$/.test(value)) {
+                    result[key] = parseInt(value, 10);
+                }
+                else if (/^\d*\.\d+$/.test(value)) {
+                    result[key] = parseFloat(value);
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Parse TOML content (basic implementation)
+     * For a full implementation, you'd want to use a proper TOML library
+     */
+    parseTOML(content) {
+        // This is a very basic TOML parser for simple key-value pairs
+        // For production use, consider integrating a proper TOML library
+        const lines = content.split('\n');
+        const result = {};
+        let currentSection = '';
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('#')) {
+                continue;
+            }
+            // Section headers [section]
+            if (trimmedLine.startsWith('[') && trimmedLine.endsWith(']')) {
+                currentSection = trimmedLine.slice(1, -1);
+                if (!result[currentSection]) {
+                    result[currentSection] = {};
+                }
+                continue;
+            }
+            // Key-value pairs
+            const equalIndex = trimmedLine.indexOf('=');
+            if (equalIndex > 0) {
+                const key = trimmedLine.substring(0, equalIndex).trim();
+                let value = trimmedLine.substring(equalIndex + 1).trim();
+                // Remove quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                // Parse value
+                let parsedValue;
+                if (value === 'true') {
+                    parsedValue = true;
+                }
+                else if (value === 'false') {
+                    parsedValue = false;
+                }
+                else if (/^\d+$/.test(value)) {
+                    parsedValue = parseInt(value, 10);
+                }
+                else if (/^\d*\.\d+$/.test(value)) {
+                    parsedValue = parseFloat(value);
+                }
+                else {
+                    parsedValue = value;
+                }
+                if (currentSection) {
+                    result[currentSection][key] = parsedValue;
+                }
+                else {
+                    result[key] = parsedValue;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Parse CSV content (basic implementation)
+     */
+    parseCSV(content) {
+        const lines = content.trim().split('\n');
+        if (lines.length === 0) {
+            return [];
+        }
+        // Parse header row
+        const headers = this.parseCSVLine(lines[0]);
+        const result = [];
+        // Parse data rows
+        for (let i = 1; i < lines.length; i++) {
+            const values = this.parseCSVLine(lines[i]);
+            const row = {};
+            for (let j = 0; j < headers.length; j++) {
+                const header = headers[j];
+                const value = j < values.length ? values[j] : '';
+                // Try to parse as number
+                if (/^\d+$/.test(value)) {
+                    row[header] = parseInt(value, 10);
+                }
+                else if (/^\d*\.\d+$/.test(value)) {
+                    row[header] = parseFloat(value);
+                }
+                else if (value === 'true') {
+                    row[header] = true;
+                }
+                else if (value === 'false') {
+                    row[header] = false;
+                }
+                else {
+                    row[header] = value;
+                }
+            }
+            result.push(row);
+        }
+        return result;
+    }
+    /**
+     * Parse a single CSV line, handling quoted values
+     */
+    parseCSVLine(line) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            if (char === '"') {
+                if (inQuotes && line[i + 1] === '"') {
+                    // Escaped quote
+                    current += '"';
+                    i++; // Skip next quote
+                }
+                else {
+                    // Toggle quote state
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (char === ',' && !inQuotes) {
+                // Field separator
+                result.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        // Add the last field
+        result.push(current.trim());
+        return result;
+    }
     /**
      * Get nested value from object using dot notation path
      * Following golang's path resolution logic