etiquetas.js 1.0.0-alpha.1

package/src/label/services/sortFunctions.js

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

@@ -0,0 +1,280 @@
+/**
+ *  * 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

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

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

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