extwee 2.3.2 → 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

@@ -2,41 +2,53 @@
  * @jest-environment jsdom
  */
 
-import '../../web-index.js';
+// Load the core web module to set up window.Extwee
+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 properties', () => {
+    it('should have all the expected immediate properties', () => {
+        // Core functionality that's immediately available
         expect(window.Extwee).toHaveProperty('parseTwee');
         expect(window.Extwee).toHaveProperty('parseJSON');
-        expect(window.Extwee).toHaveProperty('parseTWS');
         expect(window.Extwee).toHaveProperty('parseStoryFormat');
-        expect(window.Extwee).toHaveProperty('parseTwine1HTML');
         expect(window.Extwee).toHaveProperty('parseTwine2HTML');
-        expect(window.Extwee).toHaveProperty('parseTwine2ArchiveHTML');
-        expect(window.Extwee).toHaveProperty('compileTwine1HTML');
         expect(window.Extwee).toHaveProperty('compileTwine2HTML');
-        expect(window.Extwee).toHaveProperty('compileTwine2ArchiveHTML');
         expect(window.Extwee).toHaveProperty('generateIFID');
         expect(window.Extwee).toHaveProperty('Story');
         expect(window.Extwee).toHaveProperty('Passage');
         expect(window.Extwee).toHaveProperty('StoryFormat');
+        
+        // Additional parsers loaded via modular imports
+        expect(window.Extwee).toHaveProperty('parseTwine1HTML');
+        expect(window.Extwee).toHaveProperty('parseTwine2ArchiveHTML');
+        expect(window.Extwee).toHaveProperty('parseTWS');
+        expect(window.Extwee).toHaveProperty('compileTwine1HTML');
+        expect(window.Extwee).toHaveProperty('compileTwine2ArchiveHTML');
     });
 
-    it('should have the expected types', () => {
+    it('should have the expected types for immediate functions', () => {
+        // Core functionality
         expect(typeof window.Extwee.parseTwee).toBe('function');
         expect(typeof window.Extwee.parseJSON).toBe('function');
-        expect(typeof window.Extwee.parseTWS).toBe('function');
         expect(typeof window.Extwee.parseStoryFormat).toBe('function');
-        expect(typeof window.Extwee.parseTwine1HTML).toBe('function');
         expect(typeof window.Extwee.parseTwine2HTML).toBe('function');
-        expect(typeof window.Extwee.parseTwine2ArchiveHTML).toBe('function');
-        expect(typeof window.Extwee.compileTwine1HTML).toBe('function');
         expect(typeof window.Extwee.compileTwine2HTML).toBe('function');
-        expect(typeof window.Extwee.compileTwine2ArchiveHTML).toBe('function');
         expect(typeof window.Extwee.generateIFID).toBe('function');
         expect(typeof window.Extwee.Story).toBe('function');
         expect(typeof window.Extwee.Passage).toBe('function');
         expect(typeof window.Extwee.StoryFormat).toBe('function');
+        
+        // Additional parsers
+        expect(typeof window.Extwee.parseTwine1HTML).toBe('function');
+        expect(typeof window.Extwee.parseTwine2ArchiveHTML).toBe('function');
+        expect(typeof window.Extwee.parseTWS).toBe('function');
+        expect(typeof window.Extwee.compileTwine1HTML).toBe('function');
+        expect(typeof window.Extwee.compileTwine2ArchiveHTML).toBe('function');
     });
 
     it('should have the expected properties in StoryFormat', () => {

package/types/src/Story.d.ts

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

package/types/src/Twine1HTML/parse-web.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Web-optimized Twine 1 HTML parser with reduced dependencies
+ * Parses Twine 1 HTML into a Story object using lightweight DOM parsing
+ * @see {@link https://github.com/iftechfoundation/twine-specs/blob/master/twine-1-htmloutput-doc.md Twine 1 HTML Documentation}
+ * @function parse
+ * @param {string} content - Twine 1 HTML content to parse.
+ * @returns {Story} Story object
+ */
+export function parse(content: string): Story;
+import { Story } from '../Story.js';

package/types/src/Twine2ArchiveHTML/parse-web.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Web-optimized Twine 2 Archive HTML parser with reduced dependencies
+ * Parse Twine 2 Archive HTML and returns an array of story objects using browser DOM APIs.
+ * @see {@link https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-archive-spec.md Twine 2 Archive Specification}
+ * @function parse
+ * @param {string} content - Content to parse for Twine 2 HTML elements.
+ * @throws {TypeError} - Content is not a string!
+ * @returns {Array} Array of stories found in content.
+ * @example
+ * const content = '<tw-storydata name="Untitled" startnode="1" creator="Twine" creator-version="2.3.9" ifid="A1B2C3D4-E5F6-G7H8-I9J0-K1L2M3N4O5P6" zoom="1" format="Harlowe" format-version="3.1.0" options="" hidden><style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css"></style><script role="script" id="twine-user-script" type="text/twine-javascript"></script><tw-passagedata pid="1" name="Untitled Passage" tags="" position="0,0" size="100,100"></tw-passagedata></tw-storydata>';
+ * console.log(parse(content));
+ * // => [
+ * //     Story {
+ * //      name: 'Untitled',
+ * //      startnode: '1',
+ * //      creator: 'Twine',
+ * //      creatorVersion: '2.3.9',
+ * //      ifid: 'A1B2C3D4-E5F6-G7H8-I9J0-K1L2M3N4O5P6',
+ * //      zoom: '1',
+ * //      format: 'Harlowe',
+ * //      formatVersion: '3.1.0',
+ * //      options: '',
+ * //      hidden: '',
+ * //      passages: [
+ * //        Passage {
+ * //          pid: '1',
+ * //          name: 'Untitled Passage',
+ * //          tags: '',
+ * //          position: '0,0',
+ * //          size: '100,100',
+ * //          text: ''
+ * //        }
+ * //      ]
+ * //    }
+ * //   ]
+ */
+export function parse(content: string): any[];

package/types/src/Twine2HTML/parse-web.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Web-optimized Twine 2 HTML parser with reduced dependencies
+ * Parse Twine 2 HTML into Story object using lightweight DOM parsing
+ *
+ * See: Twine 2 HTML Output Specification
+ * (https://github.com/iftechfoundation/twine-specs/blob/master/twine-2-htmloutput-spec.md)
+ *
+ * Produces warnings for:
+ * - Missing name attribute on `<tw-storydata>` element.
+ * - Missing IFID attribute on `<tw-storydata>` element.
+ * - Malformed IFID attribute on `<tw-storydata>` element.
+ * @function parse
+ * @param {string} content - Twine 2 HTML content to parse.
+ * @returns {Story} Story object based on Twine 2 HTML content.
+ * @throws {TypeError} Content is not a string.
+ * @throws {Error} Not Twine 2 HTML content!
+ * @throws {Error} Cannot parse passage data without name!
+ * @throws {Error} Passages are required to have PID!
+ */
+export function parse(content: string): Story;
+import { Story } from '../Story.js';

package/types/src/Web/html-entities-lite.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Encode HTML entities
+ * @param {string} str - String to encode
+ * @returns {string} Encoded string
+ */
+export function encode(str: string): string;
+/**
+ * Decode HTML entities
+ * @param {string} str - String to decode
+ * @returns {string} Decoded string
+ */
+export function decode(str: string): string;

package/types/src/Web/semver-lite.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lightweight semantic version validation for web builds
+ * This replaces the full semver package to reduce bundle size
+ */
+/**
+ * Validates if a string is a valid semantic version
+ * @param {string} version - Version string to validate
+ * @returns {string|null} Returns the version if valid, null if invalid
+ */
+export function valid(version: string): string | null;

package/types/src/Web/uuid-lite.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Lightweight UUID v4 generator for web builds
+ * This replaces the full uuid package to reduce bundle size
+ * @returns {string} A randomly generated UUID v4 string
+ */
+export function v4(): string;

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

@@ -0,0 +1,23 @@
+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-index.d.ts

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

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

@@ -0,0 +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

@@ -0,0 +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

@@ -0,0 +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';