315 lines
11 KiB
JavaScript
315 lines
11 KiB
JavaScript
/**
|
|
* Text Processor Module
|
|
* Handles text formatting and typography enhancements like smart quotes and hyphenation
|
|
*/
|
|
import { BaseModule } from './base-module.js';
|
|
import { moduleRegistry } from './module-registry.js';
|
|
|
|
class TextProcessorModule extends BaseModule {
|
|
constructor() {
|
|
super('text-processor', 'Text Processor');
|
|
this.smartyPants = null; // Store the function reference here
|
|
this.smartypantsu = null; // Store the function reference here
|
|
this.hyphenator = null; // For hyphenation function
|
|
this.hyphenatorReady = false;
|
|
this.locale = 'en-us';
|
|
}
|
|
|
|
/**
|
|
* Load module dependencies
|
|
* @returns {Promise<boolean>} - Resolves with success status
|
|
*/
|
|
async loadDependencies() {
|
|
try {
|
|
this.reportProgress(10, "Loading dependencies");
|
|
|
|
// Load SmartyPants script dynamically
|
|
await this.loadSmartyPantsScript();
|
|
this.reportProgress(50, "SmartyPants loaded");
|
|
|
|
// Initialize hyphenation in the background, but don't wait for it
|
|
this.initializeHyphenation();
|
|
|
|
this.reportProgress(90, "Dependencies loaded");
|
|
return true;
|
|
} catch (error) {
|
|
console.error("Error loading Text Processor dependencies:", error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the SmartyPants script dynamically and wait for it to be ready
|
|
* @returns {Promise<void>}
|
|
*/
|
|
loadSmartyPantsScript() {
|
|
return new Promise((resolve, reject) => {
|
|
// Check if already loaded globally
|
|
if (typeof window.SmartyPants === 'object' && typeof window.SmartyPants.smartypants === 'function') {
|
|
this.smartyPants = window.SmartyPants.smartypants;
|
|
this.smartypantsu = window.SmartyPants.smartypantsu;
|
|
console.log("SmartyPants already loaded globally");
|
|
resolve();
|
|
return;
|
|
}
|
|
|
|
// Load the script using a script tag
|
|
const script = document.createElement('script');
|
|
script.src = '/js/smartypants.js';
|
|
script.async = false; // Load synchronously relative to other scripts
|
|
|
|
script.onload = () => {
|
|
// Use a microtask to ensure the script has executed
|
|
Promise.resolve().then(() => {
|
|
if (typeof window.SmartyPants === 'object' && typeof window.SmartyPants.smartypants === 'function') {
|
|
this.smartyPants = window.SmartyPants.smartypants;
|
|
this.smartypantsu = window.SmartyPants.smartypantsu;
|
|
console.log("SmartyPants loaded successfully via script tag");
|
|
resolve();
|
|
} else {
|
|
console.error("SmartyPants script loaded but functions not found on window.SmartyPants");
|
|
reject(new Error('SmartyPants functions not found after loading'));
|
|
}
|
|
});
|
|
};
|
|
|
|
script.onerror = () => {
|
|
console.error('Failed to load smartypants.js script');
|
|
reject(new Error('Failed to load smartypants.js script'));
|
|
};
|
|
|
|
document.head.appendChild(script);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initialize the module
|
|
* @returns {Promise<boolean>} - Resolves with success status
|
|
*/
|
|
async initialize() {
|
|
try {
|
|
this.reportProgress(70, "Initializing text processor");
|
|
|
|
// Get locale from Localization module if available
|
|
const localizationModule = moduleRegistry.getModule('localization');
|
|
if (localizationModule) {
|
|
this.locale = localizationModule.getLocale();
|
|
// Register as an observer for locale changes
|
|
localizationModule.registerObserver(this, (newLocale) => {
|
|
this.setLocale(newLocale);
|
|
});
|
|
}
|
|
|
|
// Ensure global locale is set for SmartyPants
|
|
window.locale = this.locale;
|
|
|
|
// Verify SmartyPants is available via the stored references
|
|
if (typeof this.smartyPants !== 'function') {
|
|
console.error("SmartyPants function not available for initialization");
|
|
return false;
|
|
}
|
|
|
|
// Final initialization steps
|
|
this.reportProgress(100, "Text processor ready");
|
|
return true;
|
|
} catch (error) {
|
|
console.error("Error initializing Text Processor:", error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize hyphenation using Hyphenopoly
|
|
*/
|
|
initializeHyphenation() {
|
|
// Create custom events for hyphenation loading status
|
|
const hyphenationLoadedEvent = new CustomEvent('hyphenation-loaded');
|
|
|
|
// Add listener for hyphenation loaded event
|
|
document.addEventListener('hyphenation-loaded', () => {
|
|
console.log('Hyphenation module loaded');
|
|
this.hyphenatorReady = true;
|
|
}, { once: true });
|
|
|
|
// Check if Hyphenopoly is loaded
|
|
if (window.Hyphenopoly) {
|
|
this.setupHyphenopoly();
|
|
} else {
|
|
// Set up listener for when Hyphenopoly might be loaded later
|
|
window.addEventListener('hyphenopoly-loaded', () => {
|
|
this.setupHyphenopoly();
|
|
});
|
|
|
|
// Try loading Hyphenopoly if not already loading
|
|
if (!document.querySelector('script[src*="Hyphenopoly_Loader.js"]')) {
|
|
this.loadHyphenopolyScript();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load the Hyphenopoly script
|
|
*/
|
|
loadHyphenopolyScript() {
|
|
// Create script element for loader
|
|
const script = document.createElement('script');
|
|
script.src = '/js/Hyphenopoly_Loader.js';
|
|
script.async = true;
|
|
|
|
script.onload = () => {
|
|
document.dispatchEvent(new CustomEvent('hyphenopoly-script-loaded'));
|
|
};
|
|
|
|
script.onerror = (error) => {
|
|
console.error('Failed to load Hyphenopoly:', error);
|
|
document.dispatchEvent(new CustomEvent('hyphenation-error', {
|
|
detail: { error: 'Failed to load Hyphenopoly script' }
|
|
}));
|
|
};
|
|
|
|
document.head.appendChild(script);
|
|
|
|
// Set up configuration for Hyphenopoly
|
|
window.Hyphenopoly = {
|
|
require: {
|
|
'en-us': 'FORCEHYPHENATION'
|
|
},
|
|
paths: {
|
|
maindir: '/js/',
|
|
patterndir: '/js/patterns/'
|
|
},
|
|
setup: {
|
|
selectors: {
|
|
'.hyphenate': {}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Set up Hyphenopoly when it's available
|
|
*/
|
|
setupHyphenopoly() {
|
|
// Wait for hyphenator to be available
|
|
if (window.Hyphenopoly && window.Hyphenopoly.hyphenators) {
|
|
// Get hyphenator for English
|
|
window.Hyphenopoly.hyphenators['en-us'].then((hyphenator) => {
|
|
console.log('Hyphenator ready');
|
|
this.hyphenator = hyphenator;
|
|
this.hyphenatorReady = true;
|
|
|
|
// Dispatch event that hyphenation is ready
|
|
document.dispatchEvent(new CustomEvent('hyphenation-loaded'));
|
|
}).catch(err => {
|
|
console.error('Error loading hyphenator:', err);
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the hyphenator function
|
|
* @param {Function} hyphenatorFunc - The hyphenator function
|
|
*/
|
|
setHyphenator(hyphenatorFunc) {
|
|
if (typeof hyphenatorFunc === 'function') {
|
|
this.hyphenator = hyphenatorFunc;
|
|
this.hyphenatorReady = true;
|
|
console.log("Hyphenator function set explicitly");
|
|
} else {
|
|
console.warn("Invalid hyphenator provided");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process text with SmartyPants and optional hyphenation
|
|
* @param {string} text - The text to process
|
|
* @param {boolean} useHyphenation - Whether to apply hyphenation
|
|
* @returns {string} - The processed text
|
|
*/
|
|
process(text, useHyphenation = false) {
|
|
if (!text) return '';
|
|
|
|
let processed = text;
|
|
|
|
// Apply SmartyPants for typographic punctuation using stored references
|
|
try {
|
|
if (typeof this.smartyPants === 'function') {
|
|
processed = this.smartyPants(processed);
|
|
} else {
|
|
console.warn("SmartyPants function not available for processing");
|
|
}
|
|
|
|
// Convert HTML entities to UTF-8 characters
|
|
if (typeof this.smartypantsu === 'function') {
|
|
processed = this.smartypantsu(processed);
|
|
} else {
|
|
console.warn("smartypantsu function not available for processing");
|
|
}
|
|
} catch (error) {
|
|
console.error("Error applying SmartyPants:", error);
|
|
}
|
|
|
|
// Apply hyphenation if enabled and available
|
|
if (useHyphenation && this.hyphenatorReady && this.hyphenator) {
|
|
try {
|
|
processed = this.hyphenator(processed);
|
|
} catch (error) {
|
|
console.error("Error applying hyphenation:", error);
|
|
}
|
|
}
|
|
|
|
return processed;
|
|
}
|
|
|
|
/**
|
|
* Check if hyphenation is available
|
|
* @returns {boolean} - Whether hyphenation is available
|
|
*/
|
|
isHyphenationAvailable() {
|
|
return this.hyphenatorReady && this.hyphenator !== null;
|
|
}
|
|
|
|
/**
|
|
* Apply only hyphenation to text
|
|
* @param {string} text - The text to hyphenate
|
|
* @returns {string} - The hyphenated text
|
|
*/
|
|
hyphenate(text) {
|
|
if (!text || !this.hyphenatorReady || !this.hyphenator) {
|
|
return text;
|
|
}
|
|
|
|
try {
|
|
return this.hyphenator(text);
|
|
} catch (error) {
|
|
console.error("Error hyphenating text:", error);
|
|
return text;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the locale for text processing
|
|
* @param {string} locale - The locale code (e.g., 'en-us', 'de')
|
|
*/
|
|
setLocale(locale) {
|
|
if (locale && typeof locale === 'string') {
|
|
this.locale = locale.toLowerCase();
|
|
// Update global locale for SmartyPants
|
|
window.locale = this.locale;
|
|
console.log(`TextProcessor: Locale set to ${locale}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create the singleton instance
|
|
const TextProcessor = new TextProcessorModule();
|
|
|
|
// Register with the module registry
|
|
moduleRegistry.register(TextProcessor);
|
|
|
|
// Export the module
|
|
export { TextProcessor };
|
|
|
|
// Keep a reference in window for loader system
|
|
window.TextProcessor = TextProcessor;
|