etiquetas.js 1.0.0-alpha.1

package/src/usePrinterStore.js

@@ -0,0 +1,115 @@
+import { create } from 'zustand';
+
+const createPrinterSlice = (set, get) => ({
+  printerStatus: {
+    name: 'Aguardando...',
+    connected: false,
+    status: 'disconnected',
+    hasDefaultPrinter: false,
+    message: 'Conectando ao servidor...',
+    printer: null
+  },
+  setPrinterStatus: (status) => set(() => ({ printerStatus: status })),
+  updatePrinterStatus: (updates) => set((state) => ({
+    printerStatus: { ...state.printerStatus, ...updates }
+  }))
+});
+
+const createSSESlice = (set, get) => ({
+  sseConnected: false,
+  eventSource: null,
+  setSseConnected: (connected) => set(() => ({ sseConnected: connected })),
+  setEventSource: (eventSource) => set(() => ({ eventSource })),
+  
+  connectToSSE: () => {
+    const { eventSource, setSseConnected, updatePrinterStatus, setEventSource } = get();
+    
+    // Verificar se estamos em ambiente browser
+    if (typeof EventSource === 'undefined') {
+      console.log('EventSource não disponível em ambiente Node.js');
+      setSseConnected(false);
+      updatePrinterStatus({ connected: false, status: 'disconnected' });
+      return;
+    }
+    
+    // Se já existe uma conexão, feche-a primeiro
+    if (eventSource) {
+      eventSource.close();
+    }
+    
+    try {
+      const newEventSource = new EventSource('http://localhost:9999/printer/status/stream');
+      setEventSource(newEventSource);
+      
+      newEventSource.onopen = () => {
+        console.log('Conexão SSE estabelecida com a impressora');
+        setSseConnected(true);
+        updatePrinterStatus({ status: 'connecting' });
+      };
+      
+      newEventSource.addEventListener('printer-status', (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          console.log('message =>>>>>>>>>',data);
+          let status = 'disconnected';
+          let name = 'Nenhuma impressora';
+          
+          if (!data.hasDefaultPrinter) {
+            status = 'no-printer';
+            name = 'Sem impressora configurada';
+          } else if (data.isConnected && data.printer) {
+            status = 'connected';
+            name = data.printer.name || 'Impressora';
+          } else {
+            status = 'disconnected';
+            name = data.printer?.name || 'Impressora';
+          }
+          
+          updatePrinterStatus({
+            name,
+            connected: data.isConnected || false,
+            status,
+            hasDefaultPrinter: data.hasDefaultPrinter || false,
+            message: data.message || '',
+            printer: data.printer || null
+          });
+        } catch (error) {
+          console.error('Erro ao processar dados da impressora:', error);
+        }
+      });
+      
+      newEventSource.onerror = (error) => {
+        console.error('Erro na conexão SSE:', error);
+        setSseConnected(false);
+        updatePrinterStatus({ connected: false, status: 'disconnected' });
+        newEventSource.close();
+        setEventSource(null);
+        
+        // Tentar reconectar após 5 segundos
+        setTimeout(() => {
+          get().connectToSSE();
+        }, 5000);
+      };
+    } catch (error) {
+      console.error('Erro ao conectar SSE:', error);
+      setSseConnected(false);
+      updatePrinterStatus({ connected: false, status: 'disconnected' });
+    }
+  },
+  
+  disconnectSSE: () => {
+    const { eventSource, setSseConnected, setEventSource } = get();
+    if (eventSource) {
+      eventSource.close();
+      setEventSource(null);
+    }
+    setSseConnected(false);
+  }
+});
+
+const usePrinterStore = create((set, get) => ({
+  ...createPrinterSlice(set, get),
+  ...createSSESlice(set, get)
+}));
+
+export default usePrinterStore;

package/src/variableManager.js

@@ -0,0 +1,224 @@
+/**
+ * Gerenciador de variáveis para templates de etiquetas
+ * Centraliza a lógica de mapeamento entre placeholders e dados reais
+ */
+
+class VariableManager {
+  constructor() {
+    // Define os placeholders disponíveis
+    this.templateVariables = [
+      "{{PROJETO_ID}}",
+      "{{PROJETO_NOME}}",
+      "{{PROJETO_OBS}}",
+      "{{CLIENTE_ID}}",
+      "{{CLIENTE_NOME}}",
+      "{{PECA_ID}}",
+      "{{PECA_CODIGO}}",
+      "{{PECA_REF}}",
+      "{{MODULO_REF}}",
+      "{{PECA_INDICE}}",
+      "{{PECA_INDICE2}}",
+      "{{PECA_REF}}",
+      "{{PECA_NOME}}",
+      "{{PECA_OBS}}",
+      "{{LARGURA}}",
+      "{{ALTURA}}",
+      "{{ESPESSURA}}",
+      "{{MN}}",
+      "{{MA}}",
+      "{{ML}}",
+      "{{FURO_A}}",
+      "{{FURO_A2}}",
+      "{{FURO_B}}",
+      "{{FURO_B2}}",
+      "{{FE}}",
+      "{{FD}}",
+      "{{FS}}",
+      "{{FI}}",
+      "{{INSUMO_NOME}}",
+      "{{INSUMO_ID}}",
+      "{{INSUMO_DIMENSOES}}",
+      "{{INSUMO_QTD}}",
+      "{{INSUMO_PESO}}",
+      "{{INSUMO_REF}}",
+      "{{INSUMO_MARCA}}",
+      "{{TAMPONAMENTO_ID}}",
+      "{{TAMPONAMENTO_REF}}",
+      "{{TAMPONAMENTO_QT}}",
+      "{{TAMPONAMENTO_PESO}}",
+      "{{TAMPONAMENTO_NOME}}",
+      "{{MATERIAL_NOME}}",
+      "{{PECA_TIPO}}",
+      "{{MODULO_NOME}}",
+      "{{LOTE_ID}}",
+      "{{MODULO_OBS}}",
+      "{{RETALHO_ID}}",
+      "{{DATA_CRIACAO}}",
+      "{{RETALHO_INDICE}}",
+      "{{MODULO_PECAS}}",
+      "{{LADO_USINAGEM}}",
+      "{{VOLUME_ID}}",
+      "{{VOLUME_NOME}}",
+      "{{VOLUME_PESO}}",
+      "{{VOLUME_DATA}}"
+    ];
+  }
+
+  /**
+   * Gera os valores correspondentes aos placeholders baseado nos dados da peça
+   * @param {Object} partData - Dados da peça
+   * @param {Object} partTypes - Tipos de peças disponíveis
+   * @param {Object} options - Opções adicionais (como rotação)
+   * @returns {Array} Array com os valores correspondentes aos placeholders
+   */
+  generateValues(partData, partTypes = {}, options = {}) {
+    // Calcula largura e altura considerando rotação
+    let partWidth = partData["width"];
+    let partHeight = partData["height"];
+    
+    if (partData["rotated"]) {
+      partWidth = partData["width"];
+      partHeight = partData["height"];
+    }
+
+    return [
+      partData["project_id"],
+      partData["project_description"],
+      partData["project_note"],
+      partData["project_customer_id"],
+      partData["project_customer_name"],
+      partData["id"],
+      partData["pid"],
+      partData["pref"],
+      partData["mref"],
+      partData["index"],
+      partData["number"],
+      partData["ref"],
+      partData["name"],
+      partData["note"],
+      partWidth,
+      partHeight,
+      partData["thickness"],
+      partData["materialName"] || partData["material"] || partData["material_name"],
+      partData["material_height"],
+      partData["material_width"],
+      partData["code_a"],
+      partData["code_a2"],
+      partData["code_b"],
+      partData["code_b2"],
+      partData["edge_left"],
+      partData["edge_right"],
+      partData["edge_top"],
+      partData["edge_bottom"],
+      partData["name"],
+      partData["id"],
+      partData["dimensions"],
+      partData["qt"],
+      partData["weight"],
+      partData["ref"],
+      partData["manufacturer"],
+      partData["id"],
+      partData["ref"],
+      partData["qt"],
+      partData["weight"],
+      partData["name"],
+      partData["material"],
+      partTypes[partData["type"]],
+      partData["mname"],
+      partData["group_id"] || partData["groupId"],
+      partData["mnote"],
+      partData["scrapId"],
+      partData["date"],
+      partData["scrapId"],
+      partData["moduleLength"],
+      partData["machining_side"],
+      partData["volume_id"],
+      partData["volume_name"],
+      partData["volume_weight"],
+      partData["volume_date"]
+    ];
+  }
+
+  /**
+   * Substitui placeholders em um texto pelos valores reais
+   * @param {string} text - Texto com placeholders
+   * @param {Object} partData - Dados da peça
+   * @param {Object} partTypes - Tipos de peças disponíveis
+   * @param {Object} options - Opções adicionais
+   * @returns {string} Texto com placeholders substituídos
+   */
+  replaceVariables(text, partData, partTypes = {}, options = {}) {
+    const values = this.generateValues(partData, partTypes, options);
+    return this.performReplacement(this.templateVariables, values, text);
+  }
+
+  /**
+   * Função interna para realizar as substituições
+   * @param {Array} search - Array de termos para buscar
+   * @param {Array} replace - Array de valores para substituir
+   * @param {string} subject - Texto onde fazer as substituições
+   * @returns {string} Texto com substituições realizadas
+   */
+  performReplacement(search, replace, subject, countObj) {
+    // Normalize inputs to arrays
+    const searchArray = [].concat(search);
+    const replaceArray = [].concat(replace);
+    const subjectArray = [].concat(subject);
+    const isReplaceArray = Array.isArray(replace);
+    const isSubjectArray = Array.isArray(subject);
+    
+    // Handle case where search is array but replace is string - replicate string for each search
+    const normalizedReplace = (Array.isArray(search) && typeof replace === "string") 
+      ? new Array(searchArray.length).fill(replace)
+      : replaceArray;
+    
+    // Initialize count if provided
+    if (countObj) countObj.value = 0;
+    
+    // Process each subject string
+    const result = subjectArray.map(str => {
+      if (str === "") return str;
+      
+      let processedStr = String(str);
+      searchArray.forEach((searchTerm, index) => {
+        const replacement = isReplaceArray 
+          ? (normalizedReplace[index] !== undefined ? normalizedReplace[index] : "")
+          : normalizedReplace[0] || "";
+        
+        if (countObj) {
+          countObj.value += processedStr.split(searchTerm).length - 1;
+        }
+        processedStr = processedStr.split(searchTerm).join(replacement);
+      });
+      
+      return processedStr;
+    });
+    
+    return isSubjectArray ? result : result[0];
+  }
+
+  /**
+   * Retorna os placeholders disponíveis
+   * @returns {Array} Array com todos os placeholders
+   */
+  getAvailableVariables() {
+    return [...this.templateVariables];
+  }
+
+  /**
+   * Método para compatibilidade com o código existente
+   * Retorna inputs e outputs no formato antigo
+   * @param {Object} partData - Dados da peça
+   * @param {Object} partTypes - Tipos de peças disponíveis
+   * @param {Object} options - Opções adicionais
+   * @returns {Object} Objeto com inputs e outputs
+   */
+  getLegacyFormat(partData, partTypes = {}, options = {}) {
+    return {
+      inputs: this.templateVariables,
+      outputs: this.generateValues(partData, partTypes, options)
+    };
+  }
+}
+
+export default VariableManager;