@mdfriday/foundry 25.9.3 → 25.9.5

package/dist/internal/domain/template/vo/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../internal/domain/template/vo/registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAsFlD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IACtD,yBAAyB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACzF,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACtF;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAE9D;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAgCrD;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;;OAGG;IACH,yBAAyB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAgBxF;;;OAGG;IACH,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI;IAiBpF;;;OAGG;IACH,OAAO,CAAC,gCAAgC;IAOxC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAgL5B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,0BAA0B;IAWlC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAuDjC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAuN/B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAmO7B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgM7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAkXnC;;;OAGG;IACH,OAAO,CAAC,OAAO;IAuCf;;OAEG;IACH,OAAO,CAAC,UAAU;IAelB;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkCnB;;OAEG;IACH,OAAO,CAAC,SAAS;IAoBjB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAmEtB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA+I7B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAiI5B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAgDhC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAqH7B;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IA6DlC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiCpB;;;OAGG;IACH,OAAO,CAAC,SAAS;IA0CjB;;;OAGG;IACH,OAAO,CAAC,SAAS;IA4DjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAuChB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgCpB;;;OAGG;IACH,OAAO,CAAC,cAAc;CAwDvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,eAAe,CAKnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,eAAe,CAKpF;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAQ3E"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../internal/domain/template/vo/registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAsFlD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAAC;IACtD,yBAAyB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACzF,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACtF;AAED;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAE9D;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAgCrD;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;;OAGG;IACH,yBAAyB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAgBxF;;;OAGG;IACH,oBAAoB,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI;IAiBpF;;;OAGG;IACH,OAAO,CAAC,gCAAgC;IAOxC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAgL5B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,0BAA0B;IAWlC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAuDjC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAuX/B;;OAEG;IACH,OAAO,CAAC,UAAU;IASlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgCpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAoGpB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAmO7B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgM7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IA2ZnC;;;OAGG;IACH,OAAO,CAAC,OAAO;IAuCf;;OAEG;IACH,OAAO,CAAC,UAAU;IAelB;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkCnB;;OAEG;IACH,OAAO,CAAC,SAAS;IAoBjB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAmEtB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA+I7B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAiI5B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAgDhC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAqH7B;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IA4ElC;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAuCjB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiCpB;;;OAGG;IACH,OAAO,CAAC,SAAS;IA0CjB;;;OAGG;IACH,OAAO,CAAC,SAAS;IA4DjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAuChB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgCpB;;;OAGG;IACH,OAAO,CAAC,cAAc;CAwDvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,eAAe,CAKnD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,eAAe,CAKpF;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAQ3E"}

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

@@ -629,6 +629,265 @@ class DefaultTemplateRegistry {
                 return str.charAt(0).toUpperCase() + str.slice(1);
             }
         }));
+        // Substr extracts parts of a string, beginning at the character at the specified
+        // position, and returns the specified number of characters.
+        // It normally takes two parameters: start and length.
+        // It can also take one parameter: start, i.e. length is omitted, in which case
+        // the substring starting from start until the end of the string will be returned.
+        // To extract characters from the end of the string, use a negative start number.
+        // If length is given and is negative, then that many characters will be omitted from
+        // the end of string.
+        // Equivalent to Go's Substr function in strings namespace
+        // Usage: {{ substr "hello world" 0 5 }} -> "hello"
+        // Usage: {{ substr "hello world" 6 }} -> "world"
+        // Usage: {{ substr "hello world" -5 }} -> "world"
+        // Usage: {{ substr "hello world" 0 -6 }} -> "hello"
+        funcMap.set('substr', (a, ...nums) => {
+            // Convert input to string
+            const s = String(a);
+            // Convert string to array of characters to handle Unicode properly
+            const chars = Array.from(s);
+            const rlen = chars.length;
+            let start;
+            let length;
+            // Parse arguments
+            switch (nums.length) {
+                case 0:
+                    throw new Error('too few arguments');
+                case 1:
+                    // Only start parameter provided
+                    const startNum = Number(nums[0]);
+                    if (isNaN(startNum) || !Number.isInteger(startNum)) {
+                        throw new Error('start argument must be an integer');
+                    }
+                    start = startNum;
+                    length = rlen;
+                    break;
+                case 2:
+                    // Both start and length parameters provided
+                    const startNum2 = Number(nums[0]);
+                    const lengthNum = Number(nums[1]);
+                    if (isNaN(startNum2) || !Number.isInteger(startNum2)) {
+                        throw new Error('start argument must be an integer');
+                    }
+                    if (isNaN(lengthNum) || !Number.isInteger(lengthNum)) {
+                        throw new Error('length argument must be an integer');
+                    }
+                    start = startNum2;
+                    length = lengthNum;
+                    break;
+                default:
+                    throw new Error('too many arguments');
+            }
+            // Handle empty string
+            if (rlen === 0) {
+                return '';
+            }
+            // Handle negative start (count from end)
+            if (start < 0) {
+                start += rlen;
+            }
+            // If start was originally negative beyond rlen, set to 0
+            if (start < 0) {
+                start = 0;
+            }
+            // If start is beyond the string length, return empty
+            if (start > rlen - 1) {
+                return '';
+            }
+            let end = rlen;
+            // Handle different length cases
+            if (length === 0) {
+                return '';
+            }
+            else if (length < 0) {
+                // Negative length: omit that many characters from end
+                end += length;
+            }
+            else if (length > 0) {
+                // Positive length: take that many characters from start
+                end = start + length;
+            }
+            // Validate bounds
+            if (start >= end) {
+                return '';
+            }
+            if (end < 0) {
+                return '';
+            }
+            // Clamp end to string length
+            if (end > rlen) {
+                end = rlen;
+            }
+            // Extract substring
+            return chars.slice(start, end).join('');
+        });
+        // Truncate truncates the string to the specified length
+        // Equivalent to Go's Truncate function in strings namespace
+        // Usage: {{ truncate 10 "hello world" }} -> "hello …"
+        // Usage: {{ truncate 10 "..." "hello world" }} -> "hello..."
+        // Supports HTML-aware truncation
+        funcMap.set('truncate', (lengthParam, ...options) => {
+            // Parse length parameter
+            const length = Number(lengthParam);
+            if (isNaN(length) || !Number.isInteger(length)) {
+                throw new Error('truncate length must be an integer');
+            }
+            let textParam;
+            let ellipsis = ' …';
+            // Parse options
+            switch (options.length) {
+                case 0:
+                    throw new Error('truncate requires a length and a string');
+                case 1:
+                    textParam = options[0];
+                    ellipsis = ' …';
+                    break;
+                case 2:
+                    ellipsis = String(options[0]);
+                    textParam = options[1];
+                    break;
+                default:
+                    throw new Error('too many arguments passed to truncate');
+            }
+            // Convert text to string
+            const text = String(textParam);
+            // Check if input is HTML (simple heuristic: contains HTML tags)
+            const isHTML = /<[^>]+>/.test(text);
+            // Convert to array of characters for proper Unicode handling
+            const chars = Array.from(text);
+            // If text is already shorter than or equal to length, return as-is
+            if (chars.length <= length) {
+                if (isHTML) {
+                    return text; // Return as HTML
+                }
+                return this.escapeHTML(text);
+            }
+            if (isHTML) {
+                return this.truncateHTML(text, length, ellipsis);
+            }
+            else {
+                return this.truncateText(text, length, ellipsis);
+            }
+        });
+    }
+    /**
+     * HTML escape utility function
+     */
+    escapeHTML(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+    /**
+     * Truncate plain text, breaking at word boundaries when possible
+     */
+    truncateText(text, length, ellipsis) {
+        const chars = Array.from(text);
+        if (chars.length <= length) {
+            return this.escapeHTML(text);
+        }
+        let lastWordIndex = 0;
+        let currentLen = 0;
+        // Find the best truncation point (word boundary)
+        for (let i = 0; i < chars.length && currentLen < length; i++) {
+            const char = chars[i];
+            currentLen++;
+            if (/\s/.test(char)) {
+                lastWordIndex = i;
+            }
+            // For CJK characters, each character can be a word boundary
+            if (/[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(char)) {
+                lastWordIndex = i;
+            }
+        }
+        // Determine truncation point
+        let endPos = currentLen >= length ? (lastWordIndex > 0 ? lastWordIndex : length) : chars.length;
+        const truncated = chars.slice(0, endPos).join('');
+        return this.escapeHTML(truncated) + ellipsis;
+    }
+    /**
+     * Truncate HTML text while preserving tag structure
+     */
+    truncateHTML(text, length, ellipsis) {
+        const tagRegex = /^<(\/)?([^ ]+?)(?:(\s*\/)| .*?)?>/;
+        const htmlSinglets = new Set(['br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input']);
+        const tags = [];
+        let lastWordIndex = 0;
+        let lastNonSpace = 0;
+        let currentLen = 0;
+        let endTextPos = 0;
+        let i = 0;
+        const chars = Array.from(text);
+        while (i < chars.length) {
+            const currentChar = chars[i];
+            // Check for HTML tag
+            if (currentChar === '<') {
+                const remainingText = chars.slice(i).join('');
+                const match = remainingText.match(tagRegex);
+                if (match) {
+                    const fullMatch = match[0];
+                    const isClosing = match[1] === '/';
+                    const tagName = match[2].toLowerCase();
+                    const isSelfClosing = match[3] === '/';
+                    // Skip the entire tag
+                    i += fullMatch.length;
+                    lastWordIndex = lastNonSpace;
+                    // Track non-singlet tags for proper closing
+                    const isSinglet = htmlSinglets.has(tagName);
+                    if (!isSinglet && !isSelfClosing) {
+                        tags.push({
+                            name: tagName,
+                            pos: i - fullMatch.length,
+                            openTag: !isClosing
+                        });
+                    }
+                    continue;
+                }
+            }
+            // Count actual text characters
+            currentLen++;
+            if (/\s/.test(currentChar)) {
+                lastWordIndex = lastNonSpace;
+            }
+            else if (/[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(currentChar)) {
+                // CJK characters can break at any character
+                lastWordIndex = i;
+            }
+            else {
+                lastNonSpace = i + 1;
+            }
+            if (currentLen > length) {
+                endTextPos = lastWordIndex > 0 ? lastWordIndex : i;
+                break;
+            }
+            i++;
+        }
+        if (currentLen <= length) {
+            return text; // No truncation needed
+        }
+        let output = chars.slice(0, endTextPos).join('') + ellipsis;
+        // Close any open HTML tags
+        let currentTag = null;
+        for (let j = tags.length - 1; j >= 0; j--) {
+            const tag = tags[j];
+            if (tag.pos >= endTextPos || currentTag !== null) {
+                if (currentTag !== null && currentTag.name === tag.name) {
+                    currentTag = null;
+                }
+                continue;
+            }
+            if (tag.openTag) {
+                output += `</${tag.name}>`;
+            }
+            else {
+                currentTag = tag;
+            }
+        }
+        return output;
     }
     /**
      * Register math functions
@@ -1355,6 +1614,42 @@ class DefaultTemplateRegistry {
                 .join('&');
             return queryString;
         });
+        // IsSet returns whether a given array, slice, or map has the given key defined
+        // Equivalent to Go's IsSet function in collections namespace
+        // Usage: {{ isset .array 0 }} or {{ isset .object "key" }}
+        funcMap.set('isset', (c, key) => {
+            if (c === null || c === undefined) {
+                return false;
+            }
+            // Handle arrays and slices
+            if (Array.isArray(c)) {
+                // Convert key to integer for array indexing
+                const k = Number(key);
+                if (isNaN(k) || !Number.isInteger(k)) {
+                    console.warn(`isset unable to use key of type ${typeof key} as index`);
+                    return false;
+                }
+                // Check if index is valid (within bounds)
+                return c.length > k && k >= 0;
+            }
+            // Handle objects/maps
+            if (typeof c === 'object') {
+                // For objects, check if the key exists as a property
+                return key in c;
+            }
+            // Handle strings (similar to arrays, but for character indexing)
+            if (typeof c === 'string') {
+                const k = Number(key);
+                if (isNaN(k) || !Number.isInteger(k)) {
+                    console.warn(`isset unable to use key of type ${typeof key} as index`);
+                    return false;
+                }
+                return c.length > k && k >= 0;
+            }
+            // Unsupported types
+            console.warn(`calling isset with unsupported type "${typeof c}" (${c.constructor?.name || typeof c}) will always return false.`);
+            return false;
+        });
     }
     /**
      * Core indexing implementation following Go's doIndex logic
@@ -2023,6 +2318,14 @@ class DefaultTemplateRegistry {
                     return null;
                 }
                 return this.unmarshalContent(dataStr, options);
+            },
+            // Plainify returns a copy of s with all HTML tags removed
+            // Equivalent to Go's Plainify function in transform namespace
+            // Usage: {{ "Hello <strong>world</strong>!" | transform.Plainify }} -> "Hello world!"
+            // Usage: {{ transform.Plainify "<p>Text with <br> tags</p>" }} -> "Text with tags"
+            Plainify: (s) => {
+                const str = String(s);
+                return this.stripHTML(str);
             }
         }));
         // Also register unmarshal as a standalone function for backward compatibility
@@ -2030,6 +2333,46 @@ class DefaultTemplateRegistry {
             const transform = funcMap.get('transform')();
             return transform.Unmarshal(...args);
         });
+        // Register plainify as a standalone function for convenience
+        funcMap.set('plainify', (s) => {
+            const str = String(s);
+            return this.stripHTML(str);
+        });
+    }
+    /**
+     * Strip HTML tags from a string
+     * Equivalent to Go's helpers.StripHTML function
+     * Preserves line breaks from block elements and normalizes whitespace
+     */
+    stripHTML(html) {
+        // Shortcut for strings with no HTML tags
+        if (!html.includes('<') && !html.includes('>')) {
+            return html;
+        }
+        // First pass: Replace block elements that should create line breaks
+        let result = html
+            .replace(/\n/g, ' ') // Convert newlines to spaces first
+            .replace(/<\/p>/gi, '\n') // </p> creates line break
+            .replace(/<br\s*\/?>/gi, '\n') // <br> and <br/> create line breaks
+            .replace(/<\/div>/gi, '\n') // </div> creates line break
+            .replace(/<\/h[1-6]>/gi, '\n') // Heading end tags create line breaks
+            .replace(/<\/li>/gi, '\n') // List items create line breaks
+            .replace(/<\/tr>/gi, '\n') // Table rows create line breaks
+            .replace(/<\/blockquote>/gi, '\n'); // Blockquotes create line breaks
+        // Second pass: Remove all HTML tags
+        result = result.replace(/<[^>]*>/g, '');
+        // Third pass: Normalize whitespace
+        // Convert multiple spaces to single spaces, but preserve intentional line breaks
+        const lines = result.split('\n');
+        const normalizedLines = lines.map(line => line.trim().replace(/\s+/g, ' '));
+        // Join lines back together, removing empty lines but preserving intentional breaks
+        result = normalizedLines
+            .filter(line => line.length > 0)
+            .join('\n')
+            .trim();
+        // Final cleanup: ensure we don't have multiple consecutive newlines
+        result = result.replace(/\n\s*\n/g, '\n');
+        return result;
     }
     /**
      * Unmarshal content from string based on format