extwee 2.3.5 → 2.3.7

package/src/Twine2ArchiveHTML/parse-web.js

@@ -8,23 +8,48 @@ class LightweightTwine2ArchiveParser {
   constructor(html) {
     this.html = html;
     this.doc = null;
+    this.usingDOMParser = false;
     
     // Parse HTML using browser's native DOMParser if available, otherwise fallback
     if (typeof DOMParser !== 'undefined') {
-      const parser = new DOMParser();
-      this.doc = parser.parseFromString(html, 'text/html');
+      try {
+        const parser = new DOMParser();
+        this.doc = parser.parseFromString(html, 'text/html');
+        this.usingDOMParser = true;
+        
+        // Check if parsing was successful (DOMParser doesn't throw errors, but creates error documents)
+        const parserError = this.doc.querySelector('parsererror');
+        if (parserError) {
+          console.warn('DOMParser encountered an error, falling back to regex parsing:', parserError.textContent);
+          this.doc = this.createSimpleDOM(html);
+          this.usingDOMParser = false;
+        }
+      } catch (error) {
+        console.warn('DOMParser failed, falling back to regex parsing:', error.message);
+        this.doc = this.createSimpleDOM(html);
+        this.usingDOMParser = false;
+      }
     } else {
       // Fallback for environments without DOMParser
       this.doc = this.createSimpleDOM(html);
+      this.usingDOMParser = false;
     }
   }
 
   getElementsByTagName(tagName) {
-    if (this.doc && this.doc.getElementsByTagName) {
-      return Array.from(this.doc.getElementsByTagName(tagName));
+    if (this.usingDOMParser && this.doc && this.doc.getElementsByTagName) {
+      // Use native DOM methods when DOMParser is available and working
+      const elements = Array.from(this.doc.getElementsByTagName(tagName));
+      
+      // Convert DOM elements to expected format for compatibility
+      return elements.map(element => ({
+        outerHTML: element.outerHTML,
+        // For compatibility with the original parser interface
+        toString: () => element.outerHTML
+      }));
     }
     
-    // Fallback implementation for tw-storydata elements
+    // Fallback implementation for environments without DOMParser
     if (tagName === 'tw-storydata') {
       return this.extractStoryDataElements();
     }
@@ -52,11 +77,12 @@ class LightweightTwine2ArchiveParser {
 
   // eslint-disable-next-line no-unused-vars
   createSimpleDOM(_htmlContent) {
-    // Minimal DOM-like object for fallback
+    // Minimal DOM-like object for fallback when DOMParser is not available
+    // This should only be used in very limited environments
     return {
       getElementsByTagName: (tagName) => {
         if (tagName === 'tw-storydata') {
-          return this.extractStoryDataElements(this.htmlContent);
+          return this.extractStoryDataElements();
         }
         return [];
       }

package/src/Twine2HTML/parse-web.js

@@ -10,23 +10,61 @@ class LightweightTwine2Parser {
   constructor(html) {
     this.html = html;
     this.doc = null;
+    this.usingDOMParser = false;
     
     // Parse HTML using browser's native DOMParser if available, otherwise fallback
     if (typeof DOMParser !== 'undefined') {
-      const parser = new DOMParser();
-      this.doc = parser.parseFromString(html, 'text/html');
+      try {
+        const parser = new DOMParser();
+        this.doc = parser.parseFromString(html, 'text/html');
+        this.usingDOMParser = true;
+        
+        // Check if parsing was successful (DOMParser doesn't throw errors, but creates error documents)
+        const parserError = this.doc.querySelector('parsererror');
+        if (parserError) {
+          console.warn('DOMParser encountered an error, falling back to regex parsing:', parserError.textContent);
+          this.doc = this.createSimpleDOM(html);
+          this.usingDOMParser = false;
+        }
+      } catch (error) {
+        console.warn('DOMParser failed, falling back to regex parsing:', error.message);
+        this.doc = this.createSimpleDOM(html);
+        this.usingDOMParser = false;
+      }
     } else {
       // Fallback for environments without DOMParser
       this.doc = this.createSimpleDOM(html);
+      this.usingDOMParser = false;
     }
   }
 
   getElementsByTagName(tagName) {
-    if (this.doc && this.doc.getElementsByTagName) {
-      return Array.from(this.doc.getElementsByTagName(tagName));
+    if (this.usingDOMParser && this.doc && this.doc.getElementsByTagName) {
+      // Use native DOM methods when DOMParser is available and working
+      const elements = Array.from(this.doc.getElementsByTagName(tagName));
+      
+      // Convert DOM elements to our expected format
+      return elements.map(element => {
+        const attributes = {};
+        
+        // Extract attributes using DOM methods - much more reliable than regex
+        if (element.attributes) {
+          for (let i = 0; i < element.attributes.length; i++) {
+            const attr = element.attributes[i];
+            // DOM automatically handles HTML entity decoding
+            attributes[attr.name] = attr.value;
+          }
+        }
+        
+        return {
+          attributes,
+          innerHTML: element.innerHTML || '',
+          rawText: element.textContent || element.innerText || ''
+        };
+      });
     }
     
-    // Fallback implementation
+    // Fallback implementation for environments without DOMParser or when DOM parsing fails
     if (tagName === 'tw-storydata') {
       return this.extractStoryDataElements();
     }
@@ -107,12 +145,49 @@ class LightweightTwine2Parser {
     
     const openingTag = openingTagMatch[0];
     
-    // Common attribute patterns
-    const attributeRegex = /(\w+(?:-\w+)*)=["']([^"']*)["']/g;
+    // Enhanced attribute parsing to handle multiple formats:
+    // 1. Quoted attributes: name="value" or name='value'
+    // 2. Unquoted attributes: name=value
+    // 3. Boolean attributes: hidden, selected, etc.
+    
+    // First, handle quoted attributes (including those with escaped quotes)
+    const quotedAttributeRegex = /(\w+(?:-\w+)*)=["']([^"']*)["']/g;
     let match;
 
-    while ((match = attributeRegex.exec(openingTag)) !== null) {
-      attributes[match[1]] = match[2];
+    while ((match = quotedAttributeRegex.exec(openingTag)) !== null) {
+      // Decode basic HTML entities in attribute values
+      const value = match[2]
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&'); // This should be last
+      
+      attributes[match[1]] = value;
+    }
+    
+    // Handle unquoted attributes (but avoid matching already processed quoted ones)
+    let tagWithoutQuoted = openingTag;
+    const quotedMatches = [...openingTag.matchAll(quotedAttributeRegex)];
+    quotedMatches.forEach(quotedMatch => {
+      tagWithoutQuoted = tagWithoutQuoted.replace(quotedMatch[0], '');
+    });
+    
+    const unquotedAttributeRegex = /(\w+(?:-\w+)*)=([^\s>]+)/g;
+    while ((match = unquotedAttributeRegex.exec(tagWithoutQuoted)) !== null) {
+      if (!attributes[match[1]]) { // Don't overwrite quoted attributes
+        attributes[match[1]] = match[2];
+      }
+    }
+    
+    // Handle boolean attributes (attributes without values)
+    const booleanAttributeRegex = /\s(\w+(?:-\w+)*)(?=\s|>|$)/g;
+    while ((match = booleanAttributeRegex.exec(openingTag)) !== null) {
+      const attrName = match[1];
+      // Only add if it's not already parsed as a key=value attribute and not the tag name
+      if (!attributes[attrName] && !openingTag.includes(`${attrName}=`) && attrName !== openingTag.match(/<(\w+)/)?.[1]) {
+        attributes[attrName] = true;
+      }
     }
 
     return attributes;
@@ -132,9 +207,11 @@ class LightweightTwine2Parser {
 
   // eslint-disable-next-line no-unused-vars
   createSimpleDOM(_html) {
-    // Minimal DOM-like object for fallback
+    // Minimal DOM-like object for fallback when DOMParser is not available
+    // This should only be used in very limited environments (like some older Node.js versions)
     return {
       getElementsByTagName: (tagName) => {
+        // Use regex-based extraction as fallback
         if (tagName === 'tw-storydata') {
           return this.extractStoryDataElements();
         }
@@ -201,8 +278,14 @@ function parse(content) {
    *   The name of the story.
    */
   if (Object.prototype.hasOwnProperty.call(storyData.attributes, 'name')) {
-    // Set the story name
-    story.name = storyData.attributes.name;
+    // Validate that the name is a non-empty string before setting
+    const nameValue = storyData.attributes.name;
+    if (typeof nameValue === 'string' && nameValue.trim().length > 0) {
+      story.name = nameValue.trim();
+    } else {
+      console.warn('Warning: The name attribute is empty or invalid on tw-storydata!');
+      // Keep the default name from Story constructor
+    }
   } else {
     // Name is a required field. Warn user.
     console.warn('Warning: The name attribute is missing from tw-storydata!');
@@ -215,15 +298,20 @@ function parse(content) {
    *   hyphen that uniquely identify a story (see Treaty of Babel).
    */
   if (Object.prototype.hasOwnProperty.call(storyData.attributes, 'ifid')) {
-    // Update story IFID.
-    story.IFID = storyData.attributes.ifid;
+    // Validate that the IFID is a non-empty string before setting
+    const ifidValue = storyData.attributes.ifid;
+    if (typeof ifidValue === 'string' && ifidValue.trim().length > 0) {
+      story.IFID = ifidValue.trim();
+    } else {
+      console.warn('Warning: The ifid attribute is empty or invalid on tw-storydata!');
+    }
   } else {
-    // Name is a required filed. Warn user.
+    // IFID is a required field. Warn user.
     console.warn('Warning: The ifid attribute is missing from tw-storydata!');
   }
 
-  // Check if the IFID has valid formatting.
-  if (story.IFID.match(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/) === null) {
+  // Check if the IFID has valid formatting (only if IFID was set).
+  if (story.IFID && story.IFID.match(/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/) === null) {
     // IFID is not valid.
     console.warn('Warning: The IFID is not in valid UUIDv4 formatting on tw-storydata!');
   }

package/test/Twine1HTML/Twine1HTML.Parse.Web.test.js

@@ -312,7 +312,7 @@ describe('Twine1HTML', function () {
           const el = '<div id="storeArea"><div tiddler="Test" modifier="twee">Content</div></div>';
           const s = parseTwine1HTMLWeb(el);
           expect(s.size()).toBe(1);
-          expect(s.creator).toBe('twee');
+          expect(s.creator).toBe('extwee');
         } finally {
           global.DOMParser = originalDOMParser;
         }

package/test/Twine2HTML/Twine2HTML.Parse.Web.test.js

@@ -128,7 +128,7 @@ describe('Twine2HTML', function () {
         
         const content = '<tw-storydata name="Test Story"><tw-passagedata pid="1" name="Start">Content</tw-passagedata></tw-storydata>';
         parseTwine2HTMLWeb(content);
-        expect(warningMessage).toBe('Warning: The IFID is not in valid UUIDv4 formatting on tw-storydata!');
+        expect(warningMessage).toBe('Warning: The ifid attribute is missing from tw-storydata!');
       });
 
       it('Should warn for malformed IFID', function () {
@@ -201,7 +201,7 @@ describe('Twine2HTML', function () {
       });
 
       it('Should handle quoted empty tags', function () {
-        const content = '<tw-storydata name="Test" ifid="12345678-1234-1234-1234-123456789012"><tw-passagedata pid="1" name="Start" tags=\\"\\"\\" >Content</tw-passagedata></tw-storydata>';
+        const content = '<tw-storydata name="Test" ifid="12345678-1234-1234-1234-123456789012"><tw-passagedata pid="1" name="Start" tags=\'""\'">Content</tw-passagedata></tw-storydata>';
         
         const story = parseTwine2HTMLWeb(content);
         const passage = story.getPassageByName('Start');

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

@@ -0,0 +1,136 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * Tests for package.json web exports
+ * These tests verify that users can import the web builds directly
+ */
+
+import { describe, expect, it } from '@jest/globals';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('Web build exports', () => {
+  const buildDir = path.resolve(process.cwd(), 'build');
+  
+  describe('Web build files exist', () => {
+    it('should have core web build file', () => {
+      const corePath = path.join(buildDir, 'extwee.core.min.js');
+      expect(fs.existsSync(corePath)).toBe(true);
+    });
+
+    it('should have twine1html web build file', () => {
+      const twine1Path = path.join(buildDir, 'extwee.twine1html.min.js');
+      expect(fs.existsSync(twine1Path)).toBe(true);
+    });
+
+    it('should have twine2archive web build file', () => {
+      const twine2ArchivePath = path.join(buildDir, 'extwee.twine2archive.min.js');
+      expect(fs.existsSync(twine2ArchivePath)).toBe(true);
+    });
+
+    it('should have tws web build file', () => {
+      const twsPath = path.join(buildDir, 'extwee.tws.min.js');
+      expect(fs.existsSync(twsPath)).toBe(true);
+    });
+  });
+
+  describe('Web build content validation', () => {
+    it('should have UMD wrapper in core build', () => {
+      const corePath = path.join(buildDir, 'extwee.core.min.js');
+      const content = fs.readFileSync(corePath, 'utf8');
+      
+      // Should contain UMD pattern
+      expect(content).toMatch(/function.*webpackUniversalModuleDefinition|define.*function|module\.exports.*function/);
+      
+      // Should be minified (no excessive whitespace)
+      expect(content.split('\n').length).toBeLessThan(10);
+    });
+
+    it('should have Extwee functionality in core build', () => {
+      const corePath = path.join(buildDir, 'extwee.core.min.js');
+      const content = fs.readFileSync(corePath, 'utf8');
+      
+      // Should contain core Extwee functionality
+      expect(content).toMatch(/parseTwee|parseJSON|generateIFID|Story/);
+    });
+
+    it('should have appropriate size for minified builds', () => {
+      const corePath = path.join(buildDir, 'extwee.core.min.js');
+      const stats = fs.statSync(corePath);
+      
+      // Core build should be substantial but not excessive (roughly 50-150KB)
+      expect(stats.size).toBeGreaterThan(50000); // > 50KB
+      expect(stats.size).toBeLessThan(150000);   // < 150KB
+    });
+
+    it('should have smaller specialized builds', () => {
+      const corePath = path.join(buildDir, 'extwee.core.min.js');
+      const twine1Path = path.join(buildDir, 'extwee.twine1html.min.js');
+      const coreStats = fs.statSync(corePath);
+      const twine1Stats = fs.statSync(twine1Path);
+      
+      // Specialized builds should be smaller than core
+      expect(twine1Stats.size).toBeLessThan(coreStats.size);
+    });
+  });
+
+  describe('Package.json exports configuration', () => {
+    it('should have exports field in package.json', () => {
+      const packagePath = path.resolve(process.cwd(), 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      
+      expect(packageJson.exports).toBeDefined();
+      expect(typeof packageJson.exports).toBe('object');
+    });
+
+    it('should have correct web export paths', () => {
+      const packagePath = path.resolve(process.cwd(), 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      
+      expect(packageJson.exports['.']).toBe('./index.js');
+      expect(packageJson.exports['./web']).toBe('./build/extwee.core.min.js');
+      expect(packageJson.exports['./web/core']).toBe('./build/extwee.core.min.js');
+      expect(packageJson.exports['./web/twine1html']).toBe('./build/extwee.twine1html.min.js');
+      expect(packageJson.exports['./web/twine2archive']).toBe('./build/extwee.twine2archive.min.js');
+      expect(packageJson.exports['./web/tws']).toBe('./build/extwee.tws.min.js');
+    });
+
+    it('should point to files that actually exist', () => {
+      const packagePath = path.resolve(process.cwd(), 'package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      
+      // Check each web export path exists
+      const webExports = [
+        packageJson.exports['./web'],
+        packageJson.exports['./web/core'],
+        packageJson.exports['./web/twine1html'],
+        packageJson.exports['./web/twine2archive'],
+        packageJson.exports['./web/tws']
+      ];
+      
+      for (const exportPath of webExports) {
+        const fullPath = path.resolve(process.cwd(), exportPath);
+        expect(fs.existsSync(fullPath)).toBe(true);
+      }
+    });
+  });
+
+  describe('Documentation for web exports', () => {
+    it('should provide clear usage examples', () => {
+      // This test documents how users can import the web builds
+      const usageExamples = {
+        'import Extwee from "extwee/web"': 'Core web build with most functionality',
+        'import Extwee from "extwee/web/core"': 'Same as above (explicit)',
+        'import Extwee from "extwee/web/twine1html"': 'Twine 1 HTML parsing only',
+        'import Extwee from "extwee/web/twine2archive"': 'Twine 2 Archive HTML parsing only',
+        'import Extwee from "extwee/web/tws"': 'TWS (Twine 1 workspace) parsing only'
+      };
+      
+      // Just verify we have documented the usage patterns
+      expect(Object.keys(usageExamples)).toHaveLength(5);
+      expect(usageExamples['import Extwee from "extwee/web"']).toContain('Core web build');
+    });
+  });
+});

package/types/src/Story.d.ts

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