script-engine-lib 0.4.3 → 1.0.0-rc0

package/dist/structured-text/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Interface representing a text segment with text content and associated tags
- */
-export interface TextSegment {
-    text: string;
-    tags: string[];
-}
-export { RichTextSeparator } from './rich-text-separator';
-export { RichTextValidator } from './rich-text-validator';

package/dist/structured-text/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RichTextValidator = exports.RichTextSeparator = void 0;
-var rich_text_separator_1 = require("./rich-text-separator");
-Object.defineProperty(exports, "RichTextSeparator", { enumerable: true, get: function () { return rich_text_separator_1.RichTextSeparator; } });
-var rich_text_validator_1 = require("./rich-text-validator");
-Object.defineProperty(exports, "RichTextValidator", { enumerable: true, get: function () { return rich_text_validator_1.RichTextValidator; } });
-//# sourceMappingURL=index.js.map

package/dist/structured-text/rich-text-separator.d.ts

@@ -1,48 +0,0 @@
-import { TextSegment } from '.';
-/**
- * Class to separate text with XML tags into structured segments
- */
-export declare class RichTextSeparator {
-    /**
-     * Processes a string with XML tags and returns structured text segments
-     * @param input The input string containing XML tags Sample: "text <outer>with <inner>nested</inner> content</outer>"
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @returns Array of TextSegment objects Sample: [
-          {
-            text: 'text ',
-            tags: []
-          },
-          {
-            text: 'with ',
-            tags: ['outer']
-          },
-          {
-            text: 'nested',
-            tags: ['outer', 'inner']
-          },
-          {
-            text: ' content',
-            tags: ['outer']
-          }
-        ]
-     * @throws Error if the input contains invalid tag structure
-     */
-    static process(input: string, tags?: Set<string>): TextSegment[];
-    /**
-     * Combines adjacent segments that have the same tags
-     * @param segments Array of text segments
-     * @returns Array of combined text segments
-     */
-    private static combineAdjacentSegmentsWithSameTags;
-    /**
-     * Processes text with a current stack of tags
-     * @param input Text to process
-     * @param currentTags Current stack of tags
-     * @returns Array of flat TextSegment objects
-     */
-    private static processWithTags;
-    /**
-     * Finds the position of the matching closing tag, taking into account nesting
-     */
-    private static findMatchingClosingTag;
-}

package/dist/structured-text/rich-text-separator.js

@@ -1,146 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RichTextSeparator = void 0;
-const rich_text_validator_1 = require("./rich-text-validator");
-/**
- * Class to separate text with XML tags into structured segments
- */
-class RichTextSeparator {
-    /**
-     * Processes a string with XML tags and returns structured text segments
-     * @param input The input string containing XML tags Sample: "text <outer>with <inner>nested</inner> content</outer>"
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @returns Array of TextSegment objects Sample: [
-          {
-            text: 'text ',
-            tags: []
-          },
-          {
-            text: 'with ',
-            tags: ['outer']
-          },
-          {
-            text: 'nested',
-            tags: ['outer', 'inner']
-          },
-          {
-            text: ' content',
-            tags: ['outer']
-          }
-        ]
-     * @throws Error if the input contains invalid tag structure
-     */
-    static process(input, tags) {
-        rich_text_validator_1.RichTextValidator.validate(input, tags);
-        let segments = this.processWithTags(input, []);
-        return this.combineAdjacentSegmentsWithSameTags(segments);
-    }
-    /**
-     * Combines adjacent segments that have the same tags
-     * @param segments Array of text segments
-     * @returns Array of combined text segments
-     */
-    static combineAdjacentSegmentsWithSameTags(segments) {
-        if (segments.length <= 1) {
-            return segments;
-        }
-        let result = [];
-        let current = segments[0];
-        for (let i = 1; i < segments.length; i++) {
-            let next = segments[i];
-            let tagsEqual = current.tags.length === next.tags.length && current.tags.every((tag, index) => tag === next.tags[index]);
-            if (tagsEqual) {
-                current = {
-                    text: current.text + next.text,
-                    tags: current.tags
-                };
-            }
-            else {
-                result.push(current);
-                current = next;
-            }
-        }
-        result.push(current);
-        return result;
-    }
-    /**
-     * Processes text with a current stack of tags
-     * @param input Text to process
-     * @param currentTags Current stack of tags
-     * @returns Array of flat TextSegment objects
-     */
-    static processWithTags(input, currentTags) {
-        let result = [];
-        let currentPos = 0;
-        if (input === '') {
-            return [
-                {
-                    text: '',
-                    tags: []
-                }
-            ];
-        }
-        while (currentPos < input.length) {
-            let nextTagPos = input.indexOf('<', currentPos);
-            if (nextTagPos === -1) {
-                if (currentPos < input.length) {
-                    let text = input.substring(currentPos);
-                    if (text.length > 0) {
-                        result.push({
-                            text: text,
-                            tags: [...currentTags]
-                        });
-                    }
-                }
-                break;
-            }
-            if (nextTagPos > currentPos) {
-                let text = input.substring(currentPos, nextTagPos);
-                if (text.length > 0) {
-                    result.push({
-                        text: text,
-                        tags: [...currentTags]
-                    });
-                }
-            }
-            let openTagEnd = input.indexOf('>', nextTagPos);
-            let tagName = input.substring(nextTagPos + 1, openTagEnd);
-            let closeTagStart = this.findMatchingClosingTag(input, tagName, openTagEnd + 1);
-            let tagContent = input.substring(openTagEnd + 1, closeTagStart);
-            if (tagContent.length === 0) {
-                currentPos = closeTagStart + tagName.length + 3; // +3 for '</>'
-                continue;
-            }
-            let newTags = [...currentTags, tagName];
-            let nestedSegments = this.processWithTags(tagContent, newTags);
-            result.push(...nestedSegments);
-            currentPos = closeTagStart + tagName.length + 3; // +3 for '</>'
-        }
-        return result;
-    }
-    /**
-     * Finds the position of the matching closing tag, taking into account nesting
-     */
-    static findMatchingClosingTag(input, tagName, startPos) {
-        let searchPos = startPos;
-        let nestLevel = 1;
-        while (searchPos < input.length && nestLevel > 0) {
-            let nextOpenTag = input.indexOf('<' + tagName, searchPos);
-            let nextCloseTag = input.indexOf('</' + tagName + '>', searchPos);
-            if (nextOpenTag !== -1 && nextOpenTag < nextCloseTag) {
-                nestLevel++;
-                searchPos = nextOpenTag + 1;
-            }
-            else {
-                nestLevel--;
-                if (nestLevel === 0) {
-                    return nextCloseTag;
-                }
-                searchPos = nextCloseTag + 1;
-            }
-        }
-        return input.length;
-    }
-}
-exports.RichTextSeparator = RichTextSeparator;
-//# sourceMappingURL=rich-text-separator.js.map

package/dist/structured-text/rich-text-separator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/structured-text/rich-text-separator.test.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const rich_text_separator_1 = require("./rich-text-separator");
-(0, vitest_1.describe)('RichTextSeparator', () => {
-    (0, vitest_1.describe)('process method', () => {
-        (0, vitest_1.test)('should handle empty text without tags', () => {
-            let input = '';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: '',
-                    tags: []
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle plain text without tags', () => {
-            let input = 'Simple text without any tags';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'Simple text without any tags',
-                    tags: []
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle single tag correctly', () => {
-            let input = '<b>Bold text</b>';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'Bold text',
-                    tags: ['b']
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle text with surrounding tags', () => {
-            let input = 'some text <b>with tags</b>';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'some text ',
-                    tags: []
-                },
-                {
-                    text: 'with tags',
-                    tags: ['b']
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle multiple tags', () => {
-            let input = '<h1>Header</h1> with <p>paragraph</p>';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'Header',
-                    tags: ['h1']
-                },
-                {
-                    text: ' with ',
-                    tags: []
-                },
-                {
-                    text: 'paragraph',
-                    tags: ['p']
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should ignore empty tags', () => {
-            let input = 'Text with <empty></empty>tags';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'Text with tags',
-                    tags: []
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle nested tags', () => {
-            let input = 'text <outer>with <inner>nested</inner> content</outer>';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'text ',
-                    tags: []
-                },
-                {
-                    text: 'with ',
-                    tags: ['outer']
-                },
-                {
-                    text: 'nested',
-                    tags: ['outer', 'inner']
-                },
-                {
-                    text: ' content',
-                    tags: ['outer']
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should handle the complex example from requirements', () => {
-            let input = 'some text <b>with tags</b> with <b>multiple<i>nested<n>tags</n></i></b>';
-            let result = rich_text_separator_1.RichTextSeparator.process(input);
-            (0, vitest_1.expect)(result).toEqual([
-                {
-                    text: 'some text ',
-                    tags: []
-                },
-                {
-                    text: 'with tags',
-                    tags: ['b']
-                },
-                {
-                    text: ' with ',
-                    tags: []
-                },
-                {
-                    text: 'multiple',
-                    tags: ['b']
-                },
-                {
-                    text: 'nested',
-                    tags: ['b', 'i']
-                },
-                {
-                    text: 'tags',
-                    tags: ['b', 'i', 'n']
-                }
-            ]);
-        });
-        (0, vitest_1.test)('should throw error for malformed input', () => {
-            // Missing closing tag
-            let input1 = '<div>unclosed tag';
-            (0, vitest_1.expect)(() => rich_text_separator_1.RichTextSeparator.process(input1)).toThrow(`Unclosed tag: div`);
-            // Unclosed tag with content
-            let input2 = 'text with <b>bold text but no closing tag';
-            (0, vitest_1.expect)(() => rich_text_separator_1.RichTextSeparator.process(input2)).toThrow(`Unclosed tag: b`);
-            // Mismatched tags
-            let input3 = '<div>text</span>';
-            (0, vitest_1.expect)(() => rich_text_separator_1.RichTextSeparator.process(input3)).toThrow(`Mismatched tags: expected closing tag for 'div', but found 'span' at position 9`);
-        });
-        (0, vitest_1.test)('should validate against allowed tags set', () => {
-            let allowedTags = new Set(['b', 'i', 'p']);
-            // Valid input with allowed tags
-            let validInput = 'This is <b>bold</b> and <i>italic</i> text with a <p>paragraph</p>';
-            let result = rich_text_separator_1.RichTextSeparator.process(validInput, allowedTags);
-            (0, vitest_1.expect)(result).toEqual([
-                { text: 'This is ', tags: [] },
-                { text: 'bold', tags: ['b'] },
-                { text: ' and ', tags: [] },
-                { text: 'italic', tags: ['i'] },
-                { text: ' text with a ', tags: [] },
-                { text: 'paragraph', tags: ['p'] }
-            ]);
-            // Invalid input with disallowed tag
-            let invalidInput = 'This is <b>bold</b> with <div>div tag</div>';
-            (0, vitest_1.expect)(() => rich_text_separator_1.RichTextSeparator.process(invalidInput, allowedTags)).toThrow(`Unknown tag 'div' at position 25. Only these tags are allowed: b, i, p`);
-        });
-        (0, vitest_1.test)('should process correctly with empty allowed tags set', () => {
-            let emptyAllowedTags = new Set();
-            let input = 'Text with <any>tags</any>';
-            (0, vitest_1.expect)(() => rich_text_separator_1.RichTextSeparator.process(input, emptyAllowedTags)).toThrow(`Unknown tag 'any' at position 10. Only these tags are allowed: `);
-        });
-    });
-});
-//# sourceMappingURL=rich-text-separator.test.js.map

package/dist/structured-text/rich-text-validator.d.ts

@@ -1,19 +0,0 @@
-/**
- * Class responsible for validating XML-like tags in text
- */
-export declare class RichTextValidator {
-    /**
-     * Checks if the input has valid tag structure
-     * @param input The input string containing XML-like tags
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @returns true if all tags are valid, false otherwise
-     */
-    static isValid(input: string, tags?: Set<string>): boolean;
-    /**
-     * Validates if all tags in the text are properly opened and closed
-     * @param input The input string containing XML-like tags
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @throws Error if tags are not properly formed with details about the issue
-     */
-    static validate(input: string, tags?: Set<string>): void;
-}

package/dist/structured-text/rich-text-validator.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RichTextValidator = void 0;
-/**
- * Class responsible for validating XML-like tags in text
- */
-class RichTextValidator {
-    /**
-     * Checks if the input has valid tag structure
-     * @param input The input string containing XML-like tags
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @returns true if all tags are valid, false otherwise
-     */
-    static isValid(input, tags) {
-        try {
-            this.validate(input, tags);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Validates if all tags in the text are properly opened and closed
-     * @param input The input string containing XML-like tags
-     * @param tags Optional set of allowed tags. If provided, all tags must be included in this set
-     * @throws Error if tags are not properly formed with details about the issue
-     */
-    static validate(input, tags) {
-        let stack = [];
-        let pos = 0;
-        while (pos < input.length) {
-            let tagStart = input.indexOf('<', pos);
-            if (tagStart === -1) {
-                break;
-            }
-            let isClosingTag = input[tagStart + 1] === '/';
-            let tagNameStart = tagStart + (isClosingTag ? 2 : 1);
-            let tagEnd = input.indexOf('>', tagStart);
-            if (tagEnd === -1) {
-                throw new Error(`Malformed tag at position ${tagStart}: missing closing bracket '>'`);
-            }
-            let tagName = input.substring(tagNameStart, tagEnd);
-            if (tagName.trim() === '') {
-                throw new Error(`Empty tag name found at position ${tagStart}`);
-            }
-            if (/\s/.test(tagName)) {
-                throw new Error(`Invalid tag name '${tagName}' at position ${tagStart}: contains whitespace`);
-            }
-            if (tags && !isClosingTag && !tags.has(tagName)) {
-                throw new Error(`Unknown tag '${tagName}' at position ${tagStart}. Only these tags are allowed: ${[...tags].join(', ')}`);
-            }
-            if (isClosingTag) {
-                if (stack.length === 0) {
-                    throw new Error(`Closing tag '${tagName}' at position ${tagStart} has no matching opening tag`);
-                }
-                let lastOpenTag = stack.pop();
-                if (lastOpenTag !== tagName) {
-                    throw new Error(`Mismatched tags: expected closing tag for '${lastOpenTag}', but found '${tagName}' at position ${tagStart}`);
-                }
-            }
-            else {
-                stack.push(tagName);
-            }
-            pos = tagEnd + 1;
-        }
-        if (stack.length > 0) {
-            throw new Error(`Unclosed tag${stack.length > 1 ? 's' : ''}: ${stack.join(', ')}`);
-        }
-    }
-}
-exports.RichTextValidator = RichTextValidator;
-//# sourceMappingURL=rich-text-validator.js.map

package/dist/structured-text/rich-text-validator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/structured-text/rich-text-validator.test.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const rich_text_validator_1 = require("./rich-text-validator");
-(0, vitest_1.describe)('RichTextValidator', () => {
-    (0, vitest_1.describe)('validate method', () => {
-        (0, vitest_1.test)('should not throw error for valid tag structure', () => {
-            let validInputs = [
-                'Simple text without any tags',
-                '<b>Bold text</b>',
-                'some text <b>with tags</b>',
-                '<h1>Header</h1> with <p>paragraph</p>',
-                '<outer>with <inner>nested</inner> content</outer>',
-                'some text <b>with tags</b> with <b>multiple<i>nested<n>tags</n></i></b>',
-                '' // empty string is valid
-            ];
-            validInputs.forEach(input => {
-                (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate(input)).not.toThrow();
-            });
-        });
-        (0, vitest_1.test)('should throw errors with specific messages for invalid tag structures', () => {
-            // Unclosed tag
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<div>unclosed tag')).toThrow('Unclosed tag: div');
-            // Tag with no closing bracket
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<div unclosed')).toThrow(`Malformed tag at position 0: missing closing bracket '>'`);
-            // Mismatched tags
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<div>text</span>')).toThrow(`Mismatched tags: expected closing tag for 'div', but found 'span' at position 9`);
-            // Improperly nested tags
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<a><b></a></b>')).toThrow(`Mismatched tags: expected closing tag for 'b', but found 'a' at position 6`);
-            // Empty tag
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<>')).toThrow(`Empty tag name found at position 0`);
-            // Invalid tag name with whitespace
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('< invalid>')).toThrow(`Invalid tag name ' invalid' at position 0: contains whitespace`);
-            // Closing tag without opening tag
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('</p>text')).toThrow(`Closing tag 'p' at position 0 has no matching opening tag`);
-        });
-        (0, vitest_1.test)('should validate tags against provided allowed tags set', () => {
-            let allowedTags = new Set(['b', 'i', 'p']);
-            // Valid input with allowed tags
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<b>Bold</b> and <i>italic</i>', allowedTags)).not.toThrow();
-            // Invalid input with disallowed tag
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<div>Not allowed</div>', allowedTags)).toThrow(`Unknown tag 'div' at position 0. Only these tags are allowed: b, i, p`);
-            // Mixed valid and invalid tags
-            (0, vitest_1.expect)(() => rich_text_validator_1.RichTextValidator.validate('<p>Paragraph</p> with <h1>header</h1>', allowedTags)).toThrow(`Unknown tag 'h1' at position 22. Only these tags are allowed: b, i, p`);
-        });
-    });
-    (0, vitest_1.describe)('isValid method', () => {
-        (0, vitest_1.test)('should return boolean value instead of throwing errors', () => {
-            (0, vitest_1.expect)(rich_text_validator_1.RichTextValidator.isValid('<b>valid</b>')).toBe(true);
-            (0, vitest_1.expect)(rich_text_validator_1.RichTextValidator.isValid('<div>invalid')).toBe(false);
-        });
-        (0, vitest_1.test)('should validate against allowed tags set and return boolean', () => {
-            let allowedTags = new Set(['b', 'i']);
-            (0, vitest_1.expect)(rich_text_validator_1.RichTextValidator.isValid('<b>valid</b>', allowedTags)).toBe(true);
-            (0, vitest_1.expect)(rich_text_validator_1.RichTextValidator.isValid('<span>invalid</span>', allowedTags)).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=rich-text-validator.test.js.map

package/dist/test.spec.js

@@ -1,7 +0,0 @@
-"use strict";
-describe('Test Sample', () => {
-    it('should success', () => {
-        expect(true).toBeTruthy();
-    });
-});
-//# sourceMappingURL=test.spec.js.map

package/dist/test.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test.test.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-(0, vitest_1.describe)('Test Sample', () => {
-    (0, vitest_1.test)('should success', () => {
-        (0, vitest_1.expect)(true).toBeTruthy();
-    });
-});
-//# sourceMappingURL=test.test.js.map