etiquetas.js 1.0.0-alpha.1 → 1.0.0-alpha.10

package/src/label/services/sortFunctions.js

@@ -1,158 +0,0 @@
-import pkg from "lodash";
-const { omit, groupBy } = pkg;
-
-// Função para filtrar e preparar os dados de acordo com o tipo selecionado
-export const dataTypeList = (actualFilter, values) => {
-  const value = [...values];
-  switch (actualFilter) {
-    case "input":
-      let arr = [];
-      value.map((v, k) => {
-        arr = arr.concat(
-          ...v.data.woodwork.reduce((accumulator, w, wi) => {
-            const inputsWithProjectData = w.inputs.map((input, inputIndex) => ({
-              ...input,
-              project_id: v.data.project_id,
-              project_description: v.data.project_description,
-              project_customer_id: v.data.project_customer_id,
-              project_customer_name: v.data.project_customer_name,
-              project_note: v.data.project_note,
-              mref: w.ref,
-              mname: w.name,
-              mnote: w.note,
-            }));
-            accumulator = accumulator.concat(inputsWithProjectData);
-            return accumulator;
-          }, [])
-        );
-      });
-      return groupBy(arr, "category_id");
-
-    case "part":
-      let aux = [];
-      let partNumber = 1;
-      value.map((val, key) =>
-        val.data.woodwork.map(
-          (v, k) =>
-            (aux = aux.concat(
-              ...v.parts.reduce((accumulator, part, partIndex) => {
-                accumulator = accumulator.concat({
-                  id: part.id,
-                  pid: part.id,
-                  pref: part.ref,
-                  mref: v.ref,
-                  mname: v.name,
-                  mnote: v.note,
-                  index: partNumber,
-                  number: partNumber,
-                  key: k,
-                  name: part.name,
-                  material_name: part.material_name,
-                  material_id: part.material_id,
-                  material_width: part.material_width,
-                  material_height: part.material_height,
-                  note: part.note,
-                  width: part.height,
-                  height: part.width,
-                  thickness: part.thickness,
-                  type: part.type,
-                  edge_left: part.edge_left,
-                  edge_left_id: part.edge_left_id,
-                  edge_right: part.edge_right,
-                  edge_right_id: part.edge_right_id,
-                  edge_top: part.edge_top,
-                  edge_top_id: part.edge_top_id,
-                  edge_bottom: part.edge_bottom,
-                  edge_bottom_id: part.edge_bottom_id,
-                  code_a: `${part.code_a}`,
-                  code_b: `${part.code_b}`,
-                  project_id: val.data.project_id,
-                  project_description: val.data.project_description,
-                  project_customer_id: val.data.project_customer_id,
-                  project_customer_name: val.data.project_customer_name,
-                  project_note: val.data.project_note,
-                });
-                partNumber++;
-                return accumulator;
-              }, [])
-            ))
-        )
-      );
-      return aux;
-      
-    case 'volume': 
-      return value.map((v) => {
-        return {
-          project_id: v?.volume?.project_id,
-          project_description: v?.volume?.project_name,
-          project_customer_id: '',
-          project_customer_name: v?.volume?.customer,
-          project_note: '',
-          itemList: [
-            ...(v.inputs || []),
-            ...(v.parts || []).map((part) => ({
-              ...part,
-              name: `${part.name} ${part.thickness}mm`,
-              dimensions: `${part.width} x ${part.height} mm`
-            }))
-          ],
-          volume_name: v?.volume?.description,
-          volume_id: v?.volume?.id,
-          volume_date: v?.volume?.created_at ? new Date(v.volume.created_at).toLocaleDateString('pt-BR') : '',
-          volume_weight: '0kg',
-        };
-      });
-
-    case "thickened":
-      let thickNumber = 1;
-      const thickArr = value.flatMap((v) =>
-        v.data.woodwork.reduce((accumulator, wd) => {
-          if (wd.type === "thickened") {
-            accumulator.push({
-              ...omit(wd, ["inputs", "parts"]),
-              index: thickNumber,
-              mref: wd.ref,
-              mnote: wd.note,
-              ref: null,
-              project_id: v.data.project_id,
-              project_description: v.data.project_description,
-              project_customer_id: v.data.project_customer_id,
-              project_customer_name: v.data.project_customer_name,
-              project_note: v.data.project_note,
-              rotated: true,
-            });
-            thickNumber++;
-          }
-          return accumulator;
-        }, [])
-      );
-      return thickArr;
-
-    default:
-      return [];
-  }
-};
-
-// Função para filtrar insumos por categoria
-export const getInputsByCategory = (inputs, category_id = []) => {
-  if (category_id.length === 0) {
-    return Object.values(inputs).reduce((accumulator, input) => {
-      accumulator = accumulator.concat(input);
-      return accumulator;
-    }, []);
-  }
-  return category_id.reduce((accumulator, id) => {
-    if (inputs[id]) {
-      accumulator = accumulator.concat(inputs[id]);
-    }
-    return accumulator;
-  }, []);
-};
-
-// Função para obter todas as categorias de insumos
-export const getAllCategoriesId = (inputs = []) =>
-  inputs.reduce((accumulator, input) => {
-    const ids = input.map((inp) => [inp.category_id, inp.category_name]);
-    accumulator = accumulator.concat(ids);
-    return [...new Set(accumulator)];
-  }, []); 

package/src/label/services/utils.js

@@ -1,280 +0,0 @@
-/**
- *  * Adicionar ao insertPdfToImage
-
- * Adicione essas variáveis : 
- *     // Volume information
-    "VOLUME_ID": "volume_id",
-    "VOLUME_NOME": "volume_name",
-    "VOLUME_PESO": "volume_weight",
-    "VOLUME_DATA": "volume_date",
-
-    // Additional properties
-    "MATERIAL_NOME": "material",
-    "LADO_USINAGEM": "machining_side",
-
-    "LOTE_ID": "lot_id"
- * 
- * 
- *Adicione uma nova função de specialProp
- *  case "volumeContent":
-           const xzz = generateTableSVG(currentPart.itemList, {
-            
-           });
-           const { headers, rows } = convertSVGTableToAutoTableData(currentPart.itemList);
-   
-           // Gerar a tabela no PDF
-           autoTable(pdfInstance, {
-             head: [headers], // Cabeçalho
-             body: rows,      // Linhas
-             startY: height * x + (horizontalSpace * x + marginTop) + vTop,
-             theme: 'grid',   // Estilo da tabela
-             styles: {
-                 fontSize: 4,
-                 cellPadding: 0.5,
-                 lineHeight: 0.6,
-                 minCellHeight: 1.8,
-                 overflow: 'linebreak',
-                 halign: 'center'
-             },
-             headStyles: {
-                 fillColor: [240, 240, 240],
-                 textColor: [0, 0, 0],
-                 fontStyle: 'bold',
-                 minCellHeight: 1.8
-             },
-             margin: { top: 10, right: 5, bottom: 0, left: width * y + (verticalSpace * y + marginLeft) + vLeft },
-             tableWidth: vWidth,
-             rowPageBreak:'avoid',
-             pageBreak:'auto',
-             
-             
-             showHead: 'firstPage',
-             didDrawPage: function(data) {
-                 // Quando nova página for criada, redefine Y mas mantém a mesma margem esquerda
-                 data.settings.margin.top = 0.5;
-                 data.cursor.y = 0.5 ;
-             },
-        
-             columnStyles: {
-                 // Você pode definir larguras específicas para colunas, se necessário
-             }
-         });
- */
-
-/**
- * Utility functions for the label services
- */
-
-/**
- * Converts millimeters to pixels
- * @param {number} mm - Value in millimeters
- * @returns {number} Value in pixels (assuming 96 DPI)
- */
-export const mmToPx = (mm) => {
-  // 1 mm = 3.7795275591 pixels at 96 DPI
-  return mm * 3.7795275591;
-};
-
-/**
- * Converts pixels to millimeters
- * @param {number} px - Value in pixels
- * @returns {number} Value in millimeters (assuming 96 DPI)
- */
-export const pxToMm = (px) => {
-  // 1 pixel = 0.2645833333 mm at 96 DPI
-  return px * 0.2645833333;
-};
-
-/**
- * Loads images from URLs and returns the URL (basic implementation)
- * @param {string} url - URL of the image
- * @returns {Promise<string>} The image URL
- */
-export const getImagesFromUrl = async (url) => {
-  try {
-    // Basic implementation - returns the URL as is
-    // Can be enhanced to validate the URL or fetch the image
-    if (!url || typeof url !== 'string') {
-      throw new Error('Invalid URL provided');
-    }
-    return url;
-  } catch (error) {
-    console.error('Error loading image from URL:', error);
-    return null;
-  }
-};
-
-/**
- * Loads images from URLs and converts them to Base64
- * @param {string} url - URL of the image
- * @returns {Promise<string>} Base64 encoded image data
- */
-export const getImagesFromUrlToBase64 = async (url) => {
-  try {
-    if (!url || typeof url !== 'string') {
-      throw new Error('Invalid URL provided');
-    }
-    console.log('getImagesFromUrlToBase64: Converting URL to Base64:', url);
-
-    // Browser environment handling
-    if (typeof window !== 'undefined' && typeof fetch !== 'undefined') {
-      try {
-        const response = await fetch(url);
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        
-        const blob = await response.blob();
-        
-        // Check if FileReader is available
-        if (typeof FileReader !== 'undefined') {
-          return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onloadend = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsDataURL(blob);
-          });
-        } else {
-          console.warn('FileReader not available, falling back to Node.js methods');
-          // Continue to Node.js methods
-        }
-      } catch (browserError) {
-        console.error('Browser fetch error:', browserError);
-        // Fall back to Node.js method if browser method fails
-      }
-    }
-
-    // Node.js environment handling
-    try {
-      // Dynamic import for Node.js modules
-      const fs = await import('fs').catch(() => require('fs'));
-      const path = await import('path').catch(() => require('path'));
-      
-      // Check if URL is a file path or an actual URL
-      if (url.startsWith('http://') || url.startsWith('https://')) {
-        // For HTTP URLs, use Node.js http/https modules
-        let http, https;
-        try {
-          https = await import('https').catch(() => require('https'));
-          http = await import('http').catch(() => require('http'));
-        } catch (importError) {
-          console.error('Failed to import http/https modules:', importError);
-          return null;
-        }
-
-        return new Promise((resolve, reject) => {
-          const client = url.startsWith('https') ? https : http;
-          const request = client.get(url, (response) => {
-            if (response.statusCode < 200 || response.statusCode >= 300) {
-              return reject(new Error(`HTTP Status Code: ${response.statusCode}`));
-            }
-            
-            const data = [];
-            response.on('data', (chunk) => data.push(chunk));
-            response.on('end', () => {
-              const buffer = Buffer.concat(data);
-              const base64 = `data:${response.headers['content-type'] || 'image/jpeg'};base64,${buffer.toString('base64')}`;
-              resolve(base64);
-            });
-          });
-          
-          request.on('error', (err) => {
-            console.error('HTTP request error:', err);
-            reject(err);
-          });
-        });
-      } else {
-        // For local files
-        try {
-          const localFilePath = url.startsWith('file://') ? url.slice(7) : url;
-          const buffer = fs.readFileSync(localFilePath);
-          const extension = path.extname(localFilePath).toLowerCase().substring(1);
-          const mimeType = {
-            'png': 'image/png',
-            'jpg': 'image/jpeg',
-            'jpeg': 'image/jpeg',
-            'gif': 'image/gif',
-            'webp': 'image/webp'
-          }[extension] || 'image/jpeg';
-          
-          return `data:${mimeType};base64,${buffer.toString('base64')}`;
-        } catch (fileError) {
-          console.error('Error reading local file:', fileError);
-          throw fileError;
-        }
-      }
-    } catch (nodeError) {
-      console.error('Node.js specific error:', nodeError);
-      throw nodeError;
-    }
-  } catch (error) {
-    console.error('Error converting image to Base64:', error);
-    return null;
-  }
-};
-export function convertSVGTableToAutoTableData(items) {
-  // Cabeçalhos da tabela
-  const headers = ['ID', 'Nome', 'Qtd', 'Dimensões'];
-
-  // Dados formatados para o autoTable
-  const rows = items.map(item => [
-      item.id,
-      item.name,
-      item.quantity,
-      item.dimensions
-  ]);
-
-  return { headers, rows };
-}
-
-/**
- * Generates an SVG table from item list
- * @param {Array} items - Array of items to display in table
- * @param {Object} options - Configuration options for the table
- * @returns {string} SVG string representation of the table
- */
-export function generateTableSVG(items, options = {}) {
-  if (!items || !Array.isArray(items)) {
-    return '';
-  }
-
-  const {
-    width = 200,
-    height = 100,
-    cellPadding = 5,
-    fontSize = 12,
-    headerColor = '#f0f0f0',
-    borderColor = '#000000'
-  } = options;
-
-  const headers = ['ID', 'Nome', 'Qtd', 'Dimensões'];
-  const cellWidth = width / headers.length;
-  const rowHeight = 20;
-
-  let svg = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">`;
-  
-  // Header row
-  svg += `<rect x="0" y="0" width="${width}" height="${rowHeight}" fill="${headerColor}" stroke="${borderColor}" stroke-width="1"/>`;
-  
-  headers.forEach((header, index) => {
-    const x = index * cellWidth + cellPadding;
-    const y = rowHeight / 2 + fontSize / 3;
-    svg += `<text x="${x}" y="${y}" font-size="${fontSize}" font-weight="bold" fill="black">${header}</text>`;
-  });
-
-  // Data rows
-  items.forEach((item, rowIndex) => {
-    const y = (rowIndex + 1) * rowHeight;
-    svg += `<rect x="0" y="${y}" width="${width}" height="${rowHeight}" fill="white" stroke="${borderColor}" stroke-width="1"/>`;
-    
-    const rowData = [item.id, item.name, item.quantity, item.dimensions];
-    rowData.forEach((data, colIndex) => {
-      const x = colIndex * cellWidth + cellPadding;
-      const textY = y + rowHeight / 2 + fontSize / 3;
-      svg += `<text x="${x}" y="${textY}" font-size="${fontSize}" fill="black">${data || ''}</text>`;
-    });
-  });
-
-  svg += '</svg>';
-  return svg;
-}

package/src/labelWorker.js

@@ -1,123 +0,0 @@
-import { createLabelsGenerator } from './createLabel.js';
-
-/**
- * Worker class for handling label generation without UI
- * Uses the createLabelsGenerator from createLabel.jsx
- */
-export class LabelWorker {
-  constructor() {
-    this.isGenerating = false;
-    this.currentGenerator = null;
-    this.progressCallback = null;
-  }
-
-  /**
-   * Generate labels using the generator pattern
-   * @param {Object} params - Parameters for label generation
-   * @param {Array} params.dataSource - Array of data for labels
-   * @param {Array} params.labels - Label configuration
-   * @param {Object} params.userPrefs - User preferences
-   * @param {Array} params.sheets - Sheet data
-   * @param {string} params.group - Group identifier
-   * @param {string} params.labelId - Label identifier
-   * @param {string} params.cacheKey - Cache key for the operation
-   * @param {Object} params.sheetsByPartCode - Sheets indexed by part code
-   * @param {Function} progressCallback - Callback for progress updates
-   * @returns {Promise} Promise that resolves with the generated PDF
-   */
-  async generateLabels(params, progressCallback = null) {
-    if (this.isGenerating) {
-      throw new Error('Label generation already in progress');
-    }
-
-    this.isGenerating = true;
-    this.progressCallback = progressCallback;
-
-    try {
-      this.currentGenerator = createLabelsGenerator(params);
-      
-      let result;
-      let done = false;
-      
-      while (!done) {
-        const { value, done: generatorDone } = await this.currentGenerator.next();
-        done = generatorDone;
-        
-        if (!done && value) {
-          const [percentage, cacheKey, pdfInstance] = value;
-          
-          // Call progress callback if provided
-          if (this.progressCallback) {
-            this.progressCallback({
-              percentage,
-              cacheKey,
-              pdfInstance
-            });
-          }
-        } else if (done && value) {
-          result = value;
-        }
-      }
-      
-      return result;
-    } catch (error) {
-      console.error('Error generating labels:', error);
-      throw error;
-    } finally {
-      this.isGenerating = false;
-      this.currentGenerator = null;
-      this.progressCallback = null;
-    }
-  }
-
-
-
-  /**
-   * Cancel the current label generation
-   */
-  cancel() {
-    if (this.currentGenerator) {
-      this.currentGenerator.return();
-      this.currentGenerator = null;
-    }
-    this.isGenerating = false;
-    this.progressCallback = null;
-  }
-
-  /**
-   * Check if generation is currently in progress
-   * @returns {boolean} True if generation is in progress
-   */
-  isInProgress() {
-    return this.isGenerating;
-  }
-}
-
-/**
- * Create a new instance of LabelWorker
- * @returns {LabelWorker} New worker instance
- */
-export const createLabelWorker = () => {
-  return new LabelWorker();
-};
-
-/**
- * Utility function to generate labels with data from useLabelData hook
- * @param {Object} labelData - Data from useLabelData hook
- * @param {Object} additionalParams - Additional parameters for generation
- * @param {Function} progressCallback - Progress callback
- * @returns {Promise} Promise that resolves with generated PDF
- */
-export const generateLabelsFromHookData = async (labelData, additionalParams = {}, progressCallback = null) => {
-  const worker = createLabelWorker();
-  console.log("labelData =>>>>>",labelData)
-  const params = {
-    dataSource: labelData.data || [],
-    labels: labelData.label || [],
-    userPrefs: labelData.userPrefs || {},
-    cacheKey: labelData.cacheKey,
-    ...additionalParams
-  };
-
-  return await worker.generateLabels(params, progressCallback);
-};

package/src/reducer.js

@@ -1,40 +0,0 @@
-export const initialState = {
-  type: "parts",
-  index: 0,
-  specific: false,
-  dataIndex: null,
-  source: null,
-  otherData: null,
-  category: [],
-};
-export function reducer(state, action) {
-  switch (action.type) {
-    case "CHANGE_INDEX":
-      return { ...state, index: action.payload.index };
-    case "CHANGE_TYPE":
-      return {
-        ...state,
-        type: action.payload.type,
-        specific: false,
-        source: null,
-        category: [],
-        index: 0,
-      };
-    //return {...state.components,...action.payload};
-    case "CHANGE_TO_SPECIFIC":
-      return {
-        ...state,
-        type: action.payload.type,
-        dataIndex: action.payload.source ? null : action.payload.dataIndex,
-        index: 0,
-        source: action.payload.source ? action.payload.source : null,
-        category: action.payload.category ? action.payload.category : [],
-        otherData: action.payload.otherData ? action.payload.otherData : null,
-        specific: true,
-      };
-    case "RESET":
-      return initialState;
-    default:
-      return state;
-  }
-}

package/src/store.js

@@ -1,55 +0,0 @@
-import {create} from 'zustand';
-
-const useLabelStore = create((set, get) => ({
-  // PDF Instance and basic data
-  pdfInstance: null,
-  cacheKey: null,
-  labelType: null,
-  isGenerating: false,
-  progress: 0,
-  error: null,
-  
-  // Label data
-  currentData: null,
-  currentConfig: null,
-  
-  // Setters
-  setPDFInstance: (pdfInstance, cacheKey, labelType) => set({ 
-    pdfInstance, 
-    cacheKey,
-    labelType 
-  }),
-
-  setGenerating: (isGenerating) => set({ isGenerating }),
-  
-  setProgress: (progress) => set({ progress }),
-  
-  setError: (error) => set({ error }),
-  
-  setCurrentData: (data) => set({ currentData: data }),
-  
-  setCurrentConfig: (config) => set({ currentConfig: config }),
-
-  // Reset function
-  resetPDFInstance: () => set({ 
-    pdfInstance: null, 
-    cacheKey: null,
-    labelType: null,
-    progress: 0,
-    error: null
-  }),
-  
-  // Reset all
-  reset: () => set({
-    pdfInstance: null,
-    cacheKey: null,
-    labelType: null,
-    isGenerating: false,
-    progress: 0,
-    error: null,
-    currentData: null,
-    currentConfig: null
-  }),
-}));
-
-export default useLabelStore;