e-pick 1.0.0 → 3.0.0

package/public/js/parsers/base-parser.js

@@ -0,0 +1,92 @@
+/**
+ * Base File Parser (Template Method Pattern)
+ *
+ * Defines the skeleton of the file parsing algorithm.
+ * Subclasses implement specific steps while the overall flow remains the same.
+ */
+
+class BaseFileParser {
+  /**
+   * Template method - defines the parsing algorithm structure
+   * @param {File} file - File to parse
+   * @returns {Promise<object>} Parsed data
+   */
+  async parse(file) {
+    // Step 1: Validate file
+    this.validateFile(file);
+
+    // Step 2: Read file content
+    const rawData = await this.readFile(file);
+
+    // Step 3: Structure the data
+    const structured = this.structureData(rawData);
+
+    // Step 4: Format and return result
+    return this.formatResult(structured);
+  }
+
+  /**
+   * Validate file (can be overridden by subclasses)
+   * @param {File} file - File to validate
+   * @throws {Error} If file is invalid
+   */
+  validateFile(file) {
+    if (!file) {
+      throw new Error('No file provided');
+    }
+
+    if (!this.isValidFileType(file)) {
+      throw new Error(`Invalid file type: ${file.type}`);
+    }
+  }
+
+  /**
+   * Check if file type is valid (must be implemented by subclasses)
+   * @param {File} file - File to check
+   * @returns {boolean} True if valid
+   */
+  isValidFileType(file) {
+    throw new Error('isValidFileType() must be implemented by subclass');
+  }
+
+  /**
+   * Read file content (must be implemented by subclasses)
+   * @param {File} file - File to read
+   * @returns {Promise<any>} Raw file data
+   */
+  async readFile(file) {
+    throw new Error('readFile() must be implemented by subclass');
+  }
+
+  /**
+   * Structure the raw data (must be implemented by subclasses)
+   * @param {any} rawData - Raw data from file
+   * @returns {object} Structured data with columns and rows
+   */
+  structureData(rawData) {
+    throw new Error('structureData() must be implemented by subclass');
+  }
+
+  /**
+   * Format the final result (can be overridden)
+   * @param {object} data - Structured data
+   * @returns {object} Formatted result
+   */
+  formatResult(data) {
+    // Format columns as objects with name and index
+    const formattedColumns = data.columns.map((col, index) => ({
+      name: col != null && col !== '' ? String(col) : `Column ${index + 1}`,
+      index: index
+    }));
+
+    return {
+      success: true,
+      columns: formattedColumns,
+      rows: data.rows,
+      meta: data.meta || {}
+    };
+  }
+}
+
+// Export for use in other scripts
+window.BaseFileParser = BaseFileParser;

package/public/js/parsers/csv-parser.js

@@ -0,0 +1,88 @@
+/**
+ * CSV Parser (Template Method Pattern)
+ *
+ * Implements CSV-specific parsing logic
+ */
+
+class CSVParser extends BaseFileParser {
+  /**
+   * Check if file is valid CSV type
+   * @param {File} file - File to check
+   * @returns {boolean} True if valid
+   */
+  isValidFileType(file) {
+    const validTypes = ['text/csv', 'text/plain', 'application/csv'];
+    const validExtensions = ['.csv', '.tsv', '.txt'];
+
+    const hasValidType = validTypes.includes(file.type);
+    const hasValidExtension = validExtensions.some(ext =>
+      file.name.toLowerCase().endsWith(ext)
+    );
+
+    return hasValidType || hasValidExtension || file.type === '';
+  }
+
+  /**
+   * Read CSV file
+   * @param {File} file - CSV file
+   * @returns {Promise<object>} Parsed CSV data
+   */
+  async readFile(file) {
+    return new Promise((resolve, reject) => {
+      Papa.parse(file, {
+        complete: (results) => {
+          resolve(results);
+        },
+        error: (error) => {
+          reject(new Error(`Failed to parse CSV: ${error.message}`));
+        },
+        skipEmptyLines: true
+      });
+    });
+  }
+
+  /**
+   * Structure CSV data
+   * @param {object} parsed - PapaParse result
+   * @returns {object} Structured data
+   */
+  structureData(parsed) {
+    if (!parsed.data || parsed.data.length === 0) {
+      throw new Error('CSV file is empty');
+    }
+
+    // First row is headers
+    const columns = parsed.data[0];
+    const rows = parsed.data.slice(1).filter(row =>
+      row.some(cell => cell !== null && cell !== '')
+    );
+
+    return {
+      columns,
+      rows,
+      meta: {
+        totalRows: rows.length,
+        errors: parsed.errors
+      }
+    };
+  }
+
+  /**
+   * Format result with CSV-specific metadata
+   * @param {object} data - Structured data
+   * @returns {object} Formatted result
+   */
+  formatResult(data) {
+    const result = super.formatResult(data);
+
+    // Add CSV-specific warnings if there were parsing errors
+    if (data.meta.errors && data.meta.errors.length > 0) {
+      result.warnings = data.meta.errors.map(err => err.message);
+    }
+
+    return result;
+  }
+}
+
+// Export for use in other scripts
+window.CSVParser = CSVParser;

package/public/js/parsers/excel-parser.js

@@ -0,0 +1,142 @@
+/**
+ * Excel Parser (Template Method Pattern)
+ *
+ * Implements Excel-specific parsing logic
+ */
+
+class ExcelParser extends BaseFileParser {
+  constructor() {
+    super();
+    this.workbook = null;
+  }
+
+  /**
+   * Check if file is valid Excel type
+   * @param {File} file - File to check
+   * @returns {boolean} True if valid
+   */
+  isValidFileType(file) {
+    const validTypes = [
+      'application/vnd.ms-excel',
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'application/vnd.ms-excel.sheet.macroEnabled.12'
+    ];
+
+    const validExtensions = ['.xlsx', '.xls', '.xlsm'];
+    const hasValidType = validTypes.includes(file.type);
+    const hasValidExtension = validExtensions.some(ext =>
+      file.name.toLowerCase().endsWith(ext)
+    );
+
+    return hasValidType || hasValidExtension;
+  }
+
+  /**
+   * Read Excel file
+   * @param {File} file - Excel file
+   * @returns {Promise<object>} Workbook object
+   */
+  async readFile(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+
+      reader.onload = (e) => {
+        try {
+          const data = new Uint8Array(e.target.result);
+          const workbook = XLSX.read(data, { type: 'array' });
+          this.workbook = workbook;
+          resolve(workbook);
+        } catch (error) {
+          reject(new Error(`Failed to read Excel file: ${error.message}`));
+        }
+      };
+
+      reader.onerror = () => {
+        reject(new Error('Failed to read file'));
+      };
+
+      reader.readAsArrayBuffer(file);
+    });
+  }
+
+  /**
+   * Structure workbook data
+   * @param {object} workbook - XLSX workbook
+   * @returns {object} Structured data
+   */
+  structureData(workbook) {
+    const sheetNames = workbook.SheetNames;
+
+    // Check if multiple sheets exist
+    if (sheetNames.length > 1) {
+      return {
+        needsSheetSelection: true,
+        sheets: sheetNames,
+        parser: this,
+        meta: {
+          sheetCount: sheetNames.length
+        }
+      };
+    }
+
+    // Single sheet - parse directly
+    const sheetName = sheetNames[0];
+    return this.parseSheet(workbook, sheetName);
+  }
+
+  /**
+   * Parse a specific sheet from workbook
+   * @param {object} workbook - XLSX workbook
+   * @param {string} sheetName - Sheet name to parse
+   * @returns {object} Parsed sheet data
+   */
+  parseSheet(workbook, sheetName) {
+    const worksheet = workbook.Sheets[sheetName];
+    const jsonData = XLSX.utils.sheet_to_json(worksheet, {
+      header: 1,
+      defval: ''
+    });
+
+    if (jsonData.length === 0) {
+      throw new Error('Sheet is empty');
+    }
+
+    // First row is headers
+    const columns = jsonData[0];
+    const rows = jsonData.slice(1).filter(row =>
+      row.some(cell => cell !== null && cell !== '')
+    );
+
+    return {
+      columns,
+      rows,
+      meta: {
+        sheetName,
+        totalRows: rows.length
+      }
+    };
+  }
+
+  /**
+   * Format result with Excel-specific metadata
+   * @param {object} data - Structured data
+   * @returns {object} Formatted result
+   */
+  formatResult(data) {
+    // If needs sheet selection, return early
+    if (data.needsSheetSelection) {
+      return {
+        success: true,
+        needsSheetSelection: true,
+        sheets: data.sheets,
+        parser: this,
+        meta: data.meta
+      };
+    }
+
+    return super.formatResult(data);
+  }
+}
+
+// Export for use in other scripts
+window.ExcelParser = ExcelParser;

package/public/js/parsers/parser-factory.js

@@ -0,0 +1,69 @@
+/**
+ * Parser Factory (Factory Pattern)
+ *
+ * Creates appropriate parser based on file type
+ */
+
+class ParserFactory {
+  /**
+   * Create parser for file
+   * @param {File} file - File to parse
+   * @returns {BaseFileParser} Appropriate parser instance
+   * @throws {Error} If no suitable parser found
+   */
+  static createParser(file) {
+    if (!file) {
+      throw new Error('No file provided');
+    }
+
+    // Try Excel parser first
+    const excelParser = new ExcelParser();
+    if (excelParser.isValidFileType(file)) {
+      return excelParser;
+    }
+
+    // Try CSV parser
+    const csvParser = new CSVParser();
+    if (csvParser.isValidFileType(file)) {
+      return csvParser;
+    }
+
+    // No suitable parser found
+    throw new Error(
+      `Unsupported file type: ${file.type || 'unknown'}. ` +
+      `Please upload .xlsx, .xls, or .csv files.`
+    );
+  }
+
+  /**
+   * Parse file using appropriate parser
+   * @param {File} file - File to parse
+   * @returns {Promise<object>} Parsed result
+   */
+  static async parseFile(file) {
+    const parser = ParserFactory.createParser(file);
+    return await parser.parse(file);
+  }
+
+  /**
+   * Parse specific sheet from Excel file
+   * @param {ExcelParser} parser - Excel parser instance
+   * @param {string} sheetName - Sheet name to parse
+   * @returns {object} Parsed sheet data
+   */
+  static parseSheet(parser, sheetName) {
+    if (!(parser instanceof ExcelParser)) {
+      throw new Error('Parser must be an ExcelParser instance');
+    }
+
+    if (!parser.workbook) {
+      throw new Error('No workbook loaded');
+    }
+
+    const data = parser.parseSheet(parser.workbook, sheetName);
+    return parser.formatResult(data);
+  }
+}
+
+// Export for use in other scripts
+window.ParserFactory = ParserFactory;

package/public/js/stepper-states.js

@@ -0,0 +1,319 @@
+/**
+ * Stepper States (State Pattern)
+ *
+ * Each step in the wizard is represented as a state object
+ * with specific behaviors and validation logic.
+ */
+
+/**
+ * Base Step State
+ */
+class StepState {
+  constructor(context) {
+    this.context = context;
+    this.stepNumber = 0;
+    this.stepName = 'Unknown';
+  }
+
+  /**
+   * Called when entering this step
+   */
+  enter() {
+    this.context.setCurrentStep(this.stepNumber);
+  }
+
+  /**
+   * Called when leaving this step
+   */
+  exit() {
+    // Override in subclasses if needed
+  }
+
+  /**
+   * Validate if we can proceed to next step
+   * @returns {boolean} True if can proceed
+   */
+  canProceed() {
+    return true;
+  }
+
+  /**
+   * Get next state
+   * @returns {StepState|null} Next state or null if last step
+   */
+  next() {
+    return null;
+  }
+
+  /**
+   * Get previous state
+   * @returns {StepState|null} Previous state or null if first step
+   */
+  previous() {
+    return null;
+  }
+}
+
+/**
+ * Step 1: Upload File
+ */
+class UploadFileState extends StepState {
+  constructor(context) {
+    super(context);
+    this.stepNumber = 1;
+    this.stepName = 'Upload File';
+  }
+
+  enter() {
+    super.enter();
+    // File upload UI is already visible
+  }
+
+  canProceed() {
+    return this.context.hasFile();
+  }
+
+  next() {
+    return new SelectColumnsState(this.context);
+  }
+}
+
+/**
+ * Step 2: Select Columns
+ */
+class SelectColumnsState extends StepState {
+  constructor(context) {
+    super(context);
+    this.stepNumber = 2;
+    this.stepName = 'Select Columns';
+  }
+
+  enter() {
+    super.enter();
+    // Column selectors should be visible
+  }
+
+  canProceed() {
+    return this.context.hasSelectedColumns();
+  }
+
+  next() {
+    return new ValidateState(this.context);
+  }
+
+  previous() {
+    return new UploadFileState(this.context);
+  }
+}
+
+/**
+ * Step 3: Validate
+ */
+class ValidateState extends StepState {
+  constructor(context) {
+    super(context);
+    this.stepNumber = 3;
+    this.stepName = 'Validate';
+  }
+
+  enter() {
+    super.enter();
+    // Show validation progress
+  }
+
+  canProceed() {
+    return this.context.hasValidationResults();
+  }
+
+  next() {
+    return new ReviewResultsState(this.context);
+  }
+
+  previous() {
+    return new SelectColumnsState(this.context);
+  }
+}
+
+/**
+ * Step 4: Review Results & Get Command
+ */
+class ReviewResultsState extends StepState {
+  constructor(context) {
+    super(context);
+    this.stepNumber = 4;
+    this.stepName = 'Review & Get Command';
+  }
+
+  enter() {
+    super.enter();
+    // Show validation results and command
+  }
+
+  canProceed() {
+    return this.context.hasGeneratedCommand();
+  }
+
+  next() {
+    return new ViewFilesState(this.context);
+  }
+
+  previous() {
+    return new ValidateState(this.context);
+  }
+}
+
+/**
+ * Step 5: View Changed Files
+ */
+class ViewFilesState extends StepState {
+  constructor(context) {
+    super(context);
+    this.stepNumber = 5;
+    this.stepName = 'View Changed Files';
+  }
+
+  enter() {
+    super.enter();
+    // Show changed files with diff commands
+  }
+
+  canProceed() {
+    return false; // Last step
+  }
+
+  next() {
+    return null; // No next step
+  }
+
+  previous() {
+    return new ReviewResultsState(this.context);
+  }
+}
+
+/**
+ * Stepper Context
+ * Manages state transitions
+ */
+class StepperContext {
+  constructor(uiManager) {
+    this.uiManager = uiManager;
+    this.currentState = new UploadFileState(this);
+    this.parsedData = null;
+    this.validationResults = null;
+    this.generatedCommand = null;
+  }
+
+  /**
+   * Set current step in UI
+   * @param {number} stepNumber - Step number
+   */
+  setCurrentStep(stepNumber) {
+    if (this.uiManager && this.uiManager.advanceToStep) {
+      this.uiManager.advanceToStep(stepNumber);
+    }
+  }
+
+  /**
+   * Advance to next step
+   * @returns {boolean} True if advanced successfully
+   */
+  async advanceToNext() {
+    if (!this.currentState.canProceed()) {
+      console.warn(`Cannot proceed from ${this.currentState.stepName}`);
+      return false;
+    }
+
+    const nextState = this.currentState.next();
+    if (!nextState) {
+      console.warn('Already at last step');
+      return false;
+    }
+
+    this.currentState.exit();
+    this.currentState = nextState;
+    this.currentState.enter();
+
+    return true;
+  }
+
+  /**
+   * Go back to previous step
+   * @returns {boolean} True if went back successfully
+   */
+  goToPrevious() {
+    const previousState = this.currentState.previous();
+    if (!previousState) {
+      console.warn('Already at first step');
+      return false;
+    }
+
+    this.currentState.exit();
+    this.currentState = previousState;
+    this.currentState.enter();
+
+    return true;
+  }
+
+  /**
+   * Go directly to a specific step
+   * @param {number} stepNumber - Step number to go to
+   */
+  goToStep(stepNumber) {
+    const stateMap = {
+      1: UploadFileState,
+      2: SelectColumnsState,
+      3: ValidateState,
+      4: ReviewResultsState,
+      5: ViewFilesState
+    };
+
+    const StateClass = stateMap[stepNumber];
+    if (!StateClass) {
+      console.error(`Invalid step number: ${stepNumber}`);
+      return;
+    }
+
+    this.currentState.exit();
+    this.currentState = new StateClass(this);
+    this.currentState.enter();
+  }
+
+  // Context state checks
+  hasFile() {
+    return this.parsedData !== null;
+  }
+
+  hasSelectedColumns() {
+    return true; // In current implementation, columns are always selected
+  }
+
+  hasValidationResults() {
+    return this.validationResults !== null;
+  }
+
+  hasGeneratedCommand() {
+    return this.generatedCommand !== null;
+  }
+
+  // Context state setters
+  setParsedData(data) {
+    this.parsedData = data;
+  }
+
+  setValidationResults(results) {
+    this.validationResults = results;
+  }
+
+  setGeneratedCommand(command) {
+    this.generatedCommand = command;
+  }
+}
+
+// Export for use in other scripts
+window.StepState = StepState;
+window.UploadFileState = UploadFileState;
+window.SelectColumnsState = SelectColumnsState;
+window.ValidateState = ValidateState;
+window.ReviewResultsState = ReviewResultsState;
+window.ViewFilesState = ViewFilesState;
+window.StepperContext = StepperContext;