extwee 2.3.3 → 2.3.4

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/window.Extwee.test.js

@@ -3,7 +3,12 @@
  */
 
 // Load the core web module to set up window.Extwee
-import '../../src/Web/web-index.js';
+import '../../src/Web/web-core.js';
+
+// Load additional modular parsers
+import '../../src/Web/web-twine1html.js';
+import '../../src/Web/web-twine2archive.js';
+import '../../src/Web/web-tws.js';
 
 describe('Extwee', () => {
     it('should have all the expected immediate properties', () => {
@@ -18,7 +23,7 @@ describe('Extwee', () => {
         expect(window.Extwee).toHaveProperty('Passage');
         expect(window.Extwee).toHaveProperty('StoryFormat');
         
-        // Additional parsers available in unified build
+        // Additional parsers loaded via modular imports
         expect(window.Extwee).toHaveProperty('parseTwine1HTML');
         expect(window.Extwee).toHaveProperty('parseTwine2ArchiveHTML');
         expect(window.Extwee).toHaveProperty('parseTWS');

package/types/src/Story.d.ts

@@ -251,5 +251,5 @@ export class Story {
     #private;
 }
 export const creatorName: "extwee";
-export const creatorVersion: "2.3.3";
+export const creatorVersion: "2.3.4";
 import Passage from './Passage.js';

package/types/src/Web/web-core.d.ts

@@ -1 +1,23 @@
-export {};
+export default Extwee;
+import { parse as parseTwee } from '../Twee/parse.js';
+import { parse as parseJSON } from '../JSON/parse.js';
+import { parse as parseStoryFormat } from '../StoryFormat/parse.js';
+import { parse as parseTwine2HTML } from '../Twine2HTML/parse-web.js';
+import { compile as compileTwine2HTML } from '../Twine2HTML/compile.js';
+import { generate as generateIFID } from '../IFID/generate.js';
+import { Story } from '../Story.js';
+import Passage from '../Passage.js';
+import StoryFormat from '../StoryFormat.js';
+declare namespace Extwee {
+    export { parseTwee };
+    export { parseJSON };
+    export { parseStoryFormat };
+    export { parseTwine2HTML };
+    export { compileTwine2HTML };
+    export { generateIFID };
+    export { Story };
+    export { Passage };
+    export { StoryFormat };
+    export let version: string;
+}
+export { parseTwee, parseJSON, parseStoryFormat, parseTwine2HTML, compileTwine2HTML, generateIFID, Story, Passage, StoryFormat };

package/types/src/Web/web-twine1html.d.ts

@@ -1,3 +1,10 @@
+export default Extwee;
+declare namespace Extwee {
+    export { parseTwine1HTML };
+    export { compileTwine1HTML };
+    export { parseTwine1HTML as parse };
+    export { compileTwine1HTML as compile };
+}
 import { parse as parseTwine1HTML } from '../Twine1HTML/parse-web.js';
 import { compile as compileTwine1HTML } from '../Twine1HTML/compile.js';
 export { parseTwine1HTML as parse, compileTwine1HTML as compile };

package/types/src/Web/web-twine2archive.d.ts

@@ -1,3 +1,10 @@
+export default Extwee;
+declare namespace Extwee {
+    export { parseTwine2ArchiveHTML };
+    export { compileTwine2ArchiveHTML };
+    export { parseTwine2ArchiveHTML as parse };
+    export { compileTwine2ArchiveHTML as compile };
+}
 import { parse as parseTwine2ArchiveHTML } from '../Twine2ArchiveHTML/parse-web.js';
 import { compile as compileTwine2ArchiveHTML } from '../Twine2ArchiveHTML/compile.js';
 export { parseTwine2ArchiveHTML as parse, compileTwine2ArchiveHTML as compile };

package/types/src/Web/web-tws.d.ts

@@ -1,2 +1,7 @@
+export default Extwee;
 export { parseTWS as parse };
+declare namespace Extwee {
+    export { parseTWS };
+    export { parseTWS as parse };
+}
 import { parse as parseTWS } from '../TWS/parse.js';

package/webpack.config.js

@@ -15,7 +15,8 @@ export default {
     filename: '[name].min.js',
     library: {
       type: 'umd',
-      name: 'Extwee' // Use a single library name for all modules
+      name: 'Extwee', // Use a single library name for all modules
+      export: 'default'  // Export the default export directly
     },
     globalObject: 'this'
   },

package/src/Web/web-index.js

@@ -1,31 +0,0 @@
-import { parse as parseTwee } from '../Twee/parse.js';
-import { parse as parseJSON } from '../JSON/parse.js';
-import { parse as parseStoryFormat } from '../StoryFormat/parse.js';
-import { parse as parseTwine1HTML } from '../Twine1HTML/parse.js';
-import { parse as parseTwine2HTML } from '../Twine2HTML/parse.js';
-import { parse as parseTwine2ArchiveHTML } from '../Twine2ArchiveHTML/parse.js';
-import { parse as parseTWS } from '../TWS/parse.js';
-import { compile as compileTwine1HTML } from '../Twine1HTML/compile.js';
-import { compile as compileTwine2HTML } from '../Twine2HTML/compile.js';
-import { compile as compileTwine2ArchiveHTML } from '../Twine2ArchiveHTML/compile.js';
-import { generate as generateIFID } from '../IFID/generate.js';
-import { Story } from '../Story.js';
-import Passage from '../Passage.js';
-import StoryFormat from '../StoryFormat.js';
-
-window.Extwee = {
-    parseTwee,
-    parseJSON,
-    parseTWS,
-    parseStoryFormat,
-    parseTwine1HTML,
-    parseTwine2HTML,
-    parseTwine2ArchiveHTML,
-    compileTwine1HTML,
-    compileTwine2HTML,
-    compileTwine2ArchiveHTML,
-    generateIFID,
-    Story,
-    Passage,
-    StoryFormat
-};