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

package/src/templates.js

@@ -1,139 +0,0 @@
-/**
- * 🏷️ TEMPLATES DO SISTEMA DE ETIQUETAS
- * 
- * Configurações e definições de templates para cada tipo de etiqueta
- */
-
-import { templateVariables } from './constants.js';
-import { LabelsAPI } from '../api/api.js';
-
-// ============================================================================
-// TEMPLATES DE PEÇAS
-// ============================================================================
-
-
-/**
- * Obtém um template pelo seu ID a partir da API de etiquetas
- * @param {number|string} templateId - ID do template/etiqueta a buscar
- * @returns {Promise<Object>} Template com dados da API
- */
-export async function getTemplateById(templateId) {
-  try {
-    // Converte para número se for string numérica
-
- 
-    
-    // Busca na API pelo ID
-    const labelData = await LabelsAPI.getLabel(templateId);
-    
-    if (!labelData) {
-      throw new Error(`Template/etiqueta não encontrado com ID: ${templateId}`);
-    }
-    
-  
-  
-    
-    // Retorna em formato de array conforme esperado pela função loadLabelTemplate
-    console.log('templateContent:', labelData);
-    return JSON.parse(labelData.label_content);
-  } catch (error) {
-    console.error(`Erro ao buscar template: ${error.message}`);
-    throw error;
-  }
-}
-
-/**
- * Obtém templates por tipo
- * @param {string} type - Tipo de etiqueta (parts, woodwork, inputs, scraps, volumes)
- * @returns {Array} Lista de templates do tipo especificado
- */
-export function getTemplatesByType(type) {
-  return Object.values(allTemplates).filter(template => template.type === type);
-}
-
-/**
- * Lista todos os IDs de templates disponíveis
- * @returns {Array} Lista de IDs de templates
- */
-export function getTemplateIds() {
-  return Object.keys(allTemplates);
-}
-
-/**
- * Valida se um template possui estrutura válida
- * @param {Object} template - Template a ser validado
- * @returns {boolean} True se válido, false caso contrário
- */
-export function validateTemplate(template) {
-  if (!template || typeof template !== 'object') return false;
-  
-  const requiredFields = ['id', 'name', 'type', 'pageWidth', 'pageHeight', 'elements'];
-  
-  for (const field of requiredFields) {
-    if (!(field in template)) return false;
-  }
-  
-  if (!Array.isArray(template.elements)) return false;
-  
-  return true;
-}
-
-/**
- * Obtém variáveis utilizadas em um template
- * @param {Object} template - Template a ser analisado
- * @returns {Array} Lista de variáveis encontradas
- */
-export function getTemplateVariables(template) {
-  if (!validateTemplate(template)) return [];
-  
-  const variables = new Set();
-  const variableRegex = /\{\{([^}]+)\}\}/g;
-  
-  template.elements.forEach(element => {
-    if (element.content) {
-      let match;
-      while ((match = variableRegex.exec(element.content)) !== null) {
-        variables.add(match[1]);
-      }
-    }
-  });
-  
-  return Array.from(variables);
-}
-
-/**
- * Substitui variáveis em um template com dados fornecidos
- * @param {Object} template - Template base
- * @param {Object} data - Dados para substituição
- * @returns {Object} Template com variáveis substituídas
- */
-export function replaceTemplateVariables(template, data) {
-  if (!validateTemplate(template)) return template;
-  
-  const processedTemplate = JSON.parse(JSON.stringify(template));
-  
-  processedTemplate.elements = processedTemplate.elements.map(element => {
-    if (element.content) {
-      element.content = element.content.replace(/\{\{([^}]+)\}\}/g, (match, variable) => {
-        return data[variable] || match;
-      });
-    }
-    return element;
-  });
-  
-  return processedTemplate;
-}
-
-// ============================================================================
-// EXPORTAÇÃO PADRÃO
-// ============================================================================
-
-export default {
-
-  getTemplateById,
-  getTemplatesByType,
-  getTemplateIds,
-  validateTemplate,
-  getTemplateVariables,
-  replaceTemplateVariables
-};

package/src/useLabelData.js

@@ -1,99 +0,0 @@
-// Imports básicos para o pacote npm
-import { getPartsForLabels, getPartsFromProjectToLabels } from './formatData.js';
-import { createLabelWorker } from './labelWorker.js';
-import { labelTypeNames } from './constants.js';
-
-/**
- * Hook simplificado para uso em pacote npm
- * Retorna funções utilitárias para trabalhar com dados de etiquetas
- */
-export const useLabelData = (config = {}) => {
-  // Configuração padrão
-  const defaultConfig = {
-    type: 'parts',
-    category: [],
-    specific: false,
-    dataIndex: null,
-    otherData: null,
-    source: null
-  };
-
-  const finalConfig = { ...defaultConfig, ...config };
-
-  // Função para gerar etiquetas com dados fornecidos
-  const generateLabels = async (data, labels, userPrefs = {}, additionalParams = {}) => {
-    const worker = createLabelWorker();
-    
-    const params = {
-      dataSource: data || [],
-      labels: labels || [],
-      userPrefs: userPrefs,
-      cacheKey: `label-${Date.now()}`,
-      ...additionalParams
-    };
-
-    return await worker.generateLabels(params);
-  };
-
-  // Função para download de PDF (compatível com Node.js)
-  const downloadPDF = (pdfBlob, filename = 'etiqueta.pdf') => {
-    // Em ambiente Node.js, retorna os dados do blob para processamento externo
-    if (typeof window === 'undefined') {
-      return pdfBlob;
-    }
-    
-    // Em ambiente browser, mantém funcionalidade original
-    const url = URL.createObjectURL(pdfBlob);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-  };
-
-  // Função para verificar disponibilidade da impressora
-  const checkPrinterAvailability = async () => {
-    try {
-      // Implementação básica - pode ser expandida
-      return false;
-    } catch (error) {
-      console.warn('Não foi possível verificar impressoras:', error);
-      return false;
-    }
-  };
-
-  // Função para obter dados formatados de peças
-  const getLabelData = (type = 'parts') => {
-    return {
-      data: [],
-      label: [],
-      userPrefs: {},
-      cacheKey: `${type}-${Date.now()}`
-    };
-  };
-
-  return {
-    // Estado
-    isReady: true,
-    isGenerating: false,
-    progress: 0,
-    error: null,
-    
-    // Dados
-    data: [],
-    label: [],
-    userPrefs: {},
-    cacheKey: `label-${Date.now()}`,
-    
-    // Métodos
-    generateLabels,
-    downloadPDF,
-    checkPrinterAvailability,
-    getLabelData,
-    
-    // Configuração
-    config: finalConfig
-  };
-};

package/src/usePrinterStore.js

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

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