extwee 2.3.3 → 2.3.5

package/test/Web/web-core-coverage.test.js

@@ -0,0 +1,175 @@
+/**
+ * @jest-environment node
+ */
+
+// Test the global object detection logic more comprehensively
+// by testing the function directly rather than trying to manipulate the environment
+
+describe('web-core.js comprehensive global detection coverage', () => {
+  
+  it('should test all branches of global object detection function', () => {
+    // Recreate the exact global object detection logic from web-core.js
+    const globalObjectDetectionFunction = function() {
+      if (typeof globalThis !== 'undefined') return globalThis;
+      if (typeof window !== 'undefined') return window;  
+      if (typeof global !== 'undefined') return global;
+      if (typeof self !== 'undefined') return self;
+      return null;
+    };
+
+    // Test the function logic
+    const result = globalObjectDetectionFunction();
+    
+    // In Node.js environment, should return global
+    expect(result).toBe(global);
+    
+    // Verify that global exists
+    expect(typeof global).toBe('object');
+    expect(global).toBeTruthy();
+  });
+
+  it('should test globalThis branch when globalThis is defined', () => {
+    // Test what happens when globalThis is available
+    const mockGlobalThisTest = function() {
+      // Simulate having globalThis available
+      const fakeGlobalThis = { type: 'globalThis' };
+      
+      // Mock the detection logic
+      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
+        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
+        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
+        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
+        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
+        return 'null';
+      };
+      
+      return detect(fakeGlobalThis, undefined, undefined, undefined);
+    };
+    
+    expect(mockGlobalThisTest()).toBe('globalThis');
+  });
+
+  it('should test self branch when only self is available', () => {
+    // Test what happens when only self is available (Web Worker scenario)
+    const mockSelfTest = function() {
+      const fakeSelf = { type: 'self' };
+      
+      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
+        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
+        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
+        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
+        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
+        return 'null';
+      };
+      
+      return detect(undefined, undefined, undefined, fakeSelf);
+    };
+    
+    expect(mockSelfTest()).toBe('self');
+  });
+
+  it('should test null return when no global objects are available', () => {
+    // Test what happens when no global objects are available
+    const mockNullTest = function() {
+      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
+        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return 'globalThis';
+        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return 'window';
+        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return 'global';
+        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return 'self';
+        return null;
+      };
+      
+      return detect(undefined, undefined, undefined, undefined);
+    };
+    
+    expect(mockNullTest()).toBeNull();
+  });
+
+  it('should test priority order of global object detection', () => {
+    // Test that globalThis > window > global > self priority is maintained
+    const mockPriorityTest = function() {
+      const fakeGlobalThis = { type: 'globalThis' };
+      const fakeWindow = { type: 'window' };
+      const fakeGlobal = { type: 'global' };
+      const fakeSelf = { type: 'self' };
+      
+      const detect = function(mockGlobalThis, mockWindow, mockGlobal, mockSelf) {
+        if (typeof mockGlobalThis !== 'undefined' && mockGlobalThis !== null) return mockGlobalThis;
+        if (typeof mockWindow !== 'undefined' && mockWindow !== null) return mockWindow;
+        if (typeof mockGlobal !== 'undefined' && mockGlobal !== null) return mockGlobal;
+        if (typeof mockSelf !== 'undefined' && mockSelf !== null) return mockSelf;
+        return null;
+      };
+      
+      // When all are available, should return globalThis
+      const result1 = detect(fakeGlobalThis, fakeWindow, fakeGlobal, fakeSelf);
+      expect(result1.type).toBe('globalThis');
+      
+      // When globalThis not available, should return window
+      const result2 = detect(undefined, fakeWindow, fakeGlobal, fakeSelf);
+      expect(result2.type).toBe('window');
+      
+      // When globalThis and window not available, should return global
+      const result3 = detect(undefined, undefined, fakeGlobal, fakeSelf);
+      expect(result3.type).toBe('global');
+      
+      // When only self available, should return self
+      const result4 = detect(undefined, undefined, undefined, fakeSelf);
+      expect(result4.type).toBe('self');
+    };
+    
+    mockPriorityTest();
+  });
+
+  it('should verify that global object assignment logic works', () => {
+    // Test the assignment logic without requiring module import
+    const mockAssignmentScenario = function() {
+      // Simulate Node.js environment where global is available
+      const fakeGlobal = {};
+      const fakeExtwee = { version: '2.3.3' };
+      
+      // Simulate the assignment from web-core.js
+      if (fakeGlobal) {
+        fakeGlobal.Extwee = fakeExtwee;
+      }
+      
+      return fakeGlobal;
+    };
+    
+    const result = mockAssignmentScenario();
+    expect(result.Extwee).toBeDefined();
+    expect(result.Extwee.version).toBe('2.3.3');
+  });
+
+  it('should test that assignment is conditional on globalObject being truthy', () => {
+    // This tests the `if (globalObject)` condition in the web-core.js
+    const mockAssignmentTest = function() {
+      let assignmentCalled = false;
+      
+      const mockAssign = function(globalObj, extweeObj) {
+        if (globalObj) {
+          globalObj.Extwee = extweeObj;
+          assignmentCalled = true;
+        }
+      };
+      
+      // Test with truthy global object
+      const fakeGlobal = {};
+      const fakeExtwee = { version: '2.3.3' };
+      mockAssign(fakeGlobal, fakeExtwee);
+      
+      expect(assignmentCalled).toBe(true);
+      expect(fakeGlobal.Extwee).toBe(fakeExtwee);
+      
+      // Test with null global object
+      assignmentCalled = false;
+      const fakeGlobal2 = {};
+      mockAssign(null, fakeExtwee);
+      
+      expect(assignmentCalled).toBe(false);
+      expect(fakeGlobal2.Extwee).toBeUndefined();
+    };
+    
+    mockAssignmentTest();
+  });
+});

package/test/Web/web-core-global.test.js

@@ -0,0 +1,93 @@
+/**
+ * @jest-environment jsdom
+ */
+
+// Import the module to test global assignment in jsdom environment
+import '../../src/Web/web-core.js';
+
+describe('web-core.js global assignment in browser environment', () => {
+  it('should assign Extwee to window in jsdom environment', () => {
+    // Should have assigned to window automatically on import
+    expect(window.Extwee).toBeDefined();
+    expect(window.Extwee.version).toBe('2.3.3');
+    expect(typeof window.Extwee).toBe('object');
+  });
+
+  it('should have all expected properties on window.Extwee', () => {
+    expect(window.Extwee.parseTwee).toBeDefined();
+    expect(window.Extwee.parseJSON).toBeDefined();
+    expect(window.Extwee.parseStoryFormat).toBeDefined();
+    expect(window.Extwee.parseTwine2HTML).toBeDefined();
+    expect(window.Extwee.compileTwine2HTML).toBeDefined();
+    expect(window.Extwee.generateIFID).toBeDefined();
+    expect(window.Extwee.Story).toBeDefined();
+    expect(window.Extwee.Passage).toBeDefined();
+    expect(window.Extwee.StoryFormat).toBeDefined();
+  });
+
+  it('should verify global object detection logic ran (window branch)', () => {
+    // This test verifies that the globalObject detection function found window
+    // and assigned Extwee to it
+    expect(typeof window).toBe('object');
+    expect(window).not.toBeNull();
+    expect(window.Extwee).toBeDefined();
+  });
+
+  it('should have working functions on window.Extwee', () => {
+    // Test that the assigned functions work correctly
+    const ifid = window.Extwee.generateIFID();
+    expect(ifid).toMatch(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/);
+    
+    const story = new window.Extwee.Story();
+    expect(story).toBeDefined();
+    expect(Array.isArray(story.passages)).toBe(true);
+  });
+
+  // Test to exercise the globalObject detection function
+  it('should test global object detection function directly', () => {
+    // This is a test to simulate what the global object detection function does
+    // We can't easily mock the environment during module loading, but we can
+    // verify the logic by recreating it
+    
+    const globalObjectDetectionLogic = function() {
+      if (typeof globalThis !== 'undefined') return 'globalThis';
+      if (typeof window !== 'undefined') return 'window'; 
+      if (typeof global !== 'undefined') return 'global';
+      if (typeof self !== 'undefined') return 'self';
+      return null;
+    };
+
+    // In jsdom environment, could return 'globalThis' or 'window' depending on Node.js version
+    const result = globalObjectDetectionLogic();
+    expect(['globalThis', 'window']).toContain(result);
+    
+    // Verify window exists and is truthy
+    expect(typeof window).toBe('object');
+    expect(window).toBeTruthy();
+  });
+
+  // Test for globalThis availability (Modern browsers/Node.js 12+)
+  it('should handle globalThis when available', () => {
+    // Test the globalThis branch logic
+    if (typeof globalThis !== 'undefined') {
+      expect(globalThis).toBeDefined();
+      expect(typeof globalThis).toBe('object');
+      
+      // In environments with globalThis, it should be preferred
+      const mockGlobalDetection = function() {
+        if (typeof globalThis !== 'undefined') return 'globalThis';
+        if (typeof window !== 'undefined') return 'window';
+        if (typeof global !== 'undefined') return 'global';
+        if (typeof self !== 'undefined') return 'self';
+        return null;
+      };
+      
+      // Should prefer globalThis if available
+      const detectionResult = mockGlobalDetection();
+      expect(['globalThis', 'window']).toContain(detectionResult);
+    } else {
+      // If globalThis not available, should fall back to window in jsdom
+      expect(typeof window).toBe('object');
+    }
+  });
+});

package/test/Web/web-core.test.js

@@ -0,0 +1,156 @@
+/**
+ * @jest-environment node
+ */
+
+// Import to test basic functionality
+import { parseTwee, parseJSON, parseStoryFormat, parseTwine2HTML, compileTwine2HTML, generateIFID, Story, Passage, StoryFormat } from '../../src/Web/web-core.js';
+import Extwee from '../../src/Web/web-core.js';
+
+describe('web-core.js Node.js environment tests', () => {
+  describe('ES6 module exports', () => {
+    it('should export all individual functions and classes', () => {
+      expect(parseTwee).toBeDefined();
+      expect(typeof parseTwee).toBe('function');
+      
+      expect(parseJSON).toBeDefined();
+      expect(typeof parseJSON).toBe('function');
+      
+      expect(parseStoryFormat).toBeDefined();
+      expect(typeof parseStoryFormat).toBe('function');
+      
+      expect(parseTwine2HTML).toBeDefined();
+      expect(typeof parseTwine2HTML).toBe('function');
+      
+      expect(compileTwine2HTML).toBeDefined();
+      expect(typeof compileTwine2HTML).toBe('function');
+      
+      expect(generateIFID).toBeDefined();
+      expect(typeof generateIFID).toBe('function');
+      
+      expect(Story).toBeDefined();
+      expect(typeof Story).toBe('function');
+      
+      expect(Passage).toBeDefined();
+      expect(typeof Passage).toBe('function');
+      
+      expect(StoryFormat).toBeDefined();
+      expect(typeof StoryFormat).toBe('function');
+    });
+
+    it('should export default Extwee object with all properties', () => {
+      expect(Extwee).toBeDefined();
+      expect(typeof Extwee).toBe('object');
+      
+      expect(Extwee.parseTwee).toBeDefined();
+      expect(Extwee.parseJSON).toBeDefined();
+      expect(Extwee.parseStoryFormat).toBeDefined();
+      expect(Extwee.parseTwine2HTML).toBeDefined();
+      expect(Extwee.compileTwine2HTML).toBeDefined();
+      expect(Extwee.generateIFID).toBeDefined();
+      expect(Extwee.Story).toBeDefined();
+      expect(Extwee.Passage).toBeDefined();
+      expect(Extwee.StoryFormat).toBeDefined();
+      expect(Extwee.version).toBe('2.3.3');
+    });
+
+    it('should have same functions in default export as individual exports', () => {
+      expect(Extwee.parseTwee).toBe(parseTwee);
+      expect(Extwee.parseJSON).toBe(parseJSON);
+      expect(Extwee.parseStoryFormat).toBe(parseStoryFormat);
+      expect(Extwee.parseTwine2HTML).toBe(parseTwine2HTML);
+      expect(Extwee.compileTwine2HTML).toBe(compileTwine2HTML);
+      expect(Extwee.generateIFID).toBe(generateIFID);
+      expect(Extwee.Story).toBe(Story);
+      expect(Extwee.Passage).toBe(Passage);
+      expect(Extwee.StoryFormat).toBe(StoryFormat);
+    });
+  });
+
+  describe('Functional integration tests', () => {
+    it('should have working parseTwee function', () => {
+      const tweeContent = `:: Start
+This is the start passage.`;
+      
+      const result = parseTwee(tweeContent);
+      expect(result).toBeDefined();
+      expect(result.passages).toBeDefined();
+      expect(result.passages.length).toBe(1);
+      expect(result.passages[0].name).toBe('Start');
+    });
+
+    it('should have working parseJSON function', () => {
+      const jsonContent = JSON.stringify({
+        passages: [{
+          name: 'Start',
+          text: 'This is the start passage.',
+          tags: [],
+          metadata: {}
+        }],
+        name: 'Test Story',
+        IFID: '12345678-1234-5678-9012-123456789012'
+      });
+      
+      const result = parseJSON(jsonContent);
+      expect(result).toBeDefined();
+      expect(result.passages).toBeDefined();
+      expect(result.passages.length).toBe(1);
+      expect(result.name).toBe('Test Story');
+    });
+
+    it('should have working generateIFID function', () => {
+      const ifid = generateIFID();
+      expect(ifid).toMatch(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/);
+    });
+
+    it('should have working Story constructor', () => {
+      const story = new Story();
+      expect(story).toBeDefined();
+      expect(story.passages).toBeDefined();
+      expect(Array.isArray(story.passages)).toBe(true);
+    });
+
+    it('should have working Passage constructor', () => {
+      const passage = new Passage();
+      expect(passage).toBeDefined();
+      expect(passage.name).toBeDefined();
+      expect(passage.text).toBeDefined();
+      expect(passage.tags).toBeDefined();
+      expect(Array.isArray(passage.tags)).toBe(true);
+    });
+
+    it('should have working StoryFormat constructor', () => {
+      const storyFormat = new StoryFormat();
+      expect(storyFormat).toBeDefined();
+      expect(storyFormat.name).toBeDefined();
+      expect(storyFormat.version).toBeDefined();
+    });
+  });
+
+  describe('Global assignment in Node.js environment', () => {
+    it('should assign to global.global in Node.js environment', () => {
+      // In Node.js environment, it should assign to global.global
+      expect(global.global.Extwee).toBeDefined();
+      expect(global.global.Extwee.version).toBe('2.3.3');
+      expect(global.global.Extwee).toBe(Extwee);
+    });
+    
+    it('should verify global object detection logic execution', () => {
+      // This test ensures the global object detection function runs
+      // In Node.js, typeof globalThis is 'undefined' (in older versions), 
+      // typeof window is 'undefined', typeof global is 'object', typeof self is 'undefined'
+      expect(typeof global).toBe('object');
+      expect(global.global).toBeDefined();
+    });
+  });
+
+  describe('Version consistency', () => {
+    it('should have consistent version across exports', () => {
+      expect(Extwee.version).toBe('2.3.3');
+    });
+
+    it('should have version property as string', () => {
+      expect(typeof Extwee.version).toBe('string');
+      expect(Extwee.version.length).toBeGreaterThan(0);
+    });
+  });
+});

package/test/Web/web-twine1html.test.js

@@ -0,0 +1,105 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Tests for web-twine1html.js module
+ * Tests module exports and functionality
+ */
+
+import { describe, expect, it } from '@jest/globals';
+
+// Import to test basic functionality
+import { parse, compile } from '../../src/Web/web-twine1html.js';
+import Extwee from '../../src/Web/web-twine1html.js';
+
+describe('web-twine1html.js module tests', () => {
+
+  describe('ES6 module exports', () => {
+    it('should export parse and compile functions', () => {
+      expect(parse).toBeDefined();
+      expect(compile).toBeDefined();
+      expect(typeof parse).toBe('function');
+      expect(typeof compile).toBe('function');
+    });
+
+    it('should export default object with parseTwine1HTML and compileTwine1HTML', () => {
+      expect(Extwee.parseTwine1HTML).toBeDefined();
+      expect(Extwee.compileTwine1HTML).toBeDefined();
+      expect(Extwee.parse).toBeDefined();
+      expect(Extwee.compile).toBeDefined();
+      expect(typeof Extwee.parseTwine1HTML).toBe('function');
+      expect(typeof Extwee.compileTwine1HTML).toBe('function');
+    });
+  });
+
+  describe('Global object assignment', () => {
+    it('should assign functions to global object when available', () => {
+      // In Node.js environment, should assign to globalThis
+      expect(globalThis.Extwee).toBeDefined();
+      expect(globalThis.Extwee.parseTwine1HTML).toBeDefined();
+      expect(globalThis.Extwee.compileTwine1HTML).toBeDefined();
+      expect(typeof globalThis.Extwee.parseTwine1HTML).toBe('function');
+      expect(typeof globalThis.Extwee.compileTwine1HTML).toBe('function');
+    });
+
+    it('should preserve existing Extwee properties', () => {
+      // Should not overwrite the entire object, just add properties
+      if (globalThis.Extwee && globalThis.Extwee.version) {
+        expect(globalThis.Extwee.version).toBeDefined();
+      }
+      expect(globalThis.Extwee.parseTwine1HTML).toBeDefined();
+      expect(globalThis.Extwee.compileTwine1HTML).toBeDefined();
+    });
+  });
+
+  describe('Functional integration tests', () => {
+    it('should have working parseTwine1HTML function', () => {
+      // Test with valid Twine 1 HTML
+      const sampleHtml = `
+        <html>
+          <head><title>Test</title></head>
+          <body>
+            <div id="storeArea" data-size="2">
+              <div tiddler="Start" tags="" twine-position="100,100">Start passage</div>
+            </div>
+          </body>
+        </html>
+      `;
+      
+      expect(() => {
+        const result = parse(sampleHtml);
+        expect(result).toBeDefined();
+        expect(result.passages).toBeDefined();
+      }).not.toThrow();
+    });
+
+    it('should have working compileTwine1HTML function', async () => {
+      // Import required classes dynamically to avoid circular imports
+      const { Story } = await import('../../src/Story.js');
+      const { default: Passage } = await import('../../src/Passage.js');
+      const { default: StoryFormat } = await import('../../src/StoryFormat.js');
+      
+      const story = new Story();
+      story.name = "Test Story";
+      story.addPassage(new Passage("Start", "This is the start", [], {}));
+      
+      const storyFormat = new StoryFormat();
+      storyFormat.source = "window.story = STORY;";
+      storyFormat.version = "1.0.0";
+      
+      expect(() => {
+        const result = compile(story, storyFormat, '', '', '');
+        expect(typeof result).toBe('string');
+      }).not.toThrow();
+    });
+
+    it('should have same functions in exports and global', () => {
+      // Test that parse and compile are the same functions
+      expect(parse).toBe(Extwee.parse);
+      expect(compile).toBe(Extwee.compile);
+      expect(parse).toBe(Extwee.parseTwine1HTML);
+      expect(compile).toBe(Extwee.compileTwine1HTML);
+    });
+  });
+});

package/test/Web/web-twine2archive.test.js

@@ -0,0 +1,96 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Tests for web-twine2archive.js module
+ * Tests module exports and functionality
+ */
+
+import { describe, expect, it } from '@jest/globals';
+
+// Import to test basic functionality
+import { parse, compile } from '../../src/Web/web-twine2archive.js';
+import Extwee from '../../src/Web/web-twine2archive.js';
+
+describe('web-twine2archive.js module tests', () => {
+
+  describe('ES6 module exports', () => {
+    it('should export parse and compile functions', () => {
+      expect(parse).toBeDefined();
+      expect(compile).toBeDefined();
+      expect(typeof parse).toBe('function');
+      expect(typeof compile).toBe('function');
+    });
+
+    it('should export default object with parseTwine2ArchiveHTML and compileTwine2ArchiveHTML', () => {
+      expect(Extwee.parseTwine2ArchiveHTML).toBeDefined();
+      expect(Extwee.compileTwine2ArchiveHTML).toBeDefined();
+      expect(Extwee.parse).toBeDefined();
+      expect(Extwee.compile).toBeDefined();
+      expect(typeof Extwee.parseTwine2ArchiveHTML).toBe('function');
+      expect(typeof Extwee.compileTwine2ArchiveHTML).toBe('function');
+    });
+  });
+
+  describe('Global object assignment', () => {
+    it('should assign functions to global object when available', () => {
+      // In Node.js environment, should assign to globalThis
+      expect(globalThis.Extwee).toBeDefined();
+      expect(globalThis.Extwee.parseTwine2ArchiveHTML).toBeDefined();
+      expect(globalThis.Extwee.compileTwine2ArchiveHTML).toBeDefined();
+      expect(typeof globalThis.Extwee.parseTwine2ArchiveHTML).toBe('function');
+      expect(typeof globalThis.Extwee.compileTwine2ArchiveHTML).toBe('function');
+    });
+
+    it('should preserve existing Extwee properties', () => {
+      // Should not overwrite the entire object, just add properties
+      if (globalThis.Extwee && globalThis.Extwee.version) {
+        expect(globalThis.Extwee.version).toBeDefined();
+      }
+      expect(globalThis.Extwee.parseTwine2ArchiveHTML).toBeDefined();
+      expect(globalThis.Extwee.compileTwine2ArchiveHTML).toBeDefined();
+    });
+  });
+
+  describe('Functional integration tests', () => {
+    it('should have working parseTwine2ArchiveHTML function', () => {
+      // Test with valid Twine 2 Archive HTML
+      const sampleHtml = `
+        <tw-storydata name="Test" startnode="1" creator="Twine" creator-version="2.3.5">
+          <tw-passagedata pid="1" name="Start" tags="">Start passage</tw-passagedata>
+        </tw-storydata>
+      `;
+      
+      expect(() => {
+        const result = parse(sampleHtml);
+        expect(result).toBeDefined();
+        expect(Array.isArray(result)).toBe(true);
+      }).not.toThrow();
+    });
+
+    it('should have working compileTwine2ArchiveHTML function', async () => {
+      // Import required classes
+      const { Story } = await import('../../src/Story.js');
+      const { default: Passage } = await import('../../src/Passage.js');
+      
+      const story = new Story();
+      story.name = "Test Story";
+      story.IFID = "12345678-1234-5678-9012-123456789012";
+      story.addPassage(new Passage("Start", "This is the start", [], {}));
+      
+      expect(() => {
+        const result = compile([story]);
+        expect(typeof result).toBe('string');
+      }).not.toThrow();
+    });
+
+    it('should have same functions in exports and global', () => {
+      // Test that parse and compile are the same functions
+      expect(parse).toBe(Extwee.parse);
+      expect(compile).toBe(Extwee.compile);
+      expect(parse).toBe(Extwee.parseTwine2ArchiveHTML);
+      expect(compile).toBe(Extwee.compileTwine2ArchiveHTML);
+    });
+  });
+});