etiquetas.js 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/{index-BkmabrFq.js → index-B10y8IWE.js}

@@ -11303,7 +11303,7 @@ function(t2) {
  */
 function(t2) {
   function e2() {
-    return (n.canvg ? Promise.resolve(n.canvg) : import("./index.es-B4lKWyrH.js")).catch(function(t3) {
+    return (n.canvg ? Promise.resolve(n.canvg) : import("./index.es-D4Dr85b7.js")).catch(function(t3) {
       return Promise.reject(new Error("Could not load canvg: " + t3));
     }).then(function(t3) {
       return t3.default ? t3.default : t3;
@@ -58104,16 +58104,228 @@ const makeLamination = (mainObject) => {
   }
   return pdf.output("datauristring");
 };
-const LabelsAPI$1 = {
-  getLabel: (id) => __async(void 0, null, function* () {
-    console.warn("LabelsAPI não carregado - usando placeholder");
-    return null;
-  })
+const API_BASE_URL = "https://db33.dev.dinabox.net/api";
+const apiClient$1 = axios.create({
+  baseURL: API_BASE_URL,
+  timeout: 1e4,
+  headers: {
+    "Content-Type": "application/json",
+    "Accept": "application/json"
+  }
+});
+const LABEL_TYPES$1 = {
+  PART: "part",
+  SCRAP: "scrap",
+  THICKENED: "thickened",
+  INPUT: "input",
+  VOLUME: "volume"
 };
+apiClient$1.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    var _a2;
+    console.error("Erro na API:", ((_a2 = error.response) == null ? void 0 : _a2.data) || error.message);
+    return Promise.reject(error);
+  }
+);
+class LabelsAPI {
+  /**
+   * Lista etiquetas com filtros opcionais
+   * GET /v1/labels
+   * 
+   * @param {Object} params - Parâmetros de consulta
+   * @param {number} [params.p] - Página
+   * @param {string} [params.s] - Busca
+   * @param {number} [params.label_id] - ID da etiqueta
+   * @param {string} [params.label_type] - Tipo da etiqueta (part, scrap, thickened, input, volume)
+   * @returns {Promise} Resposta da API
+   */
+  static getLabels() {
+    return __async(this, arguments, function* (params = {}) {
+      try {
+        const response = yield apiClient$1.get("/v1/labels", { params });
+        return response.data;
+      } catch (error) {
+        throw new Error(`Erro ao buscar etiquetas: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Busca etiquetas por página
+   * 
+   * @param {number} page - Número da página
+   * @param {Object} filters - Filtros adicionais
+   * @returns {Promise} Resposta da API
+   */
+  static getLabelsByPage() {
+    return __async(this, arguments, function* (page = 1, filters = {}) {
+      return this.getLabels(__spreadValues({ p: page }, filters));
+    });
+  }
+  /**
+   * Busca etiquetas por termo de pesquisa
+   * 
+   * @param {string} searchTerm - Termo de busca
+   * @param {Object} filters - Filtros adicionais
+   * @returns {Promise} Resposta da API
+   */
+  static searchLabels(_0) {
+    return __async(this, arguments, function* (searchTerm, filters = {}) {
+      return this.getLabels(__spreadValues({ s: searchTerm }, filters));
+    });
+  }
+  /**
+   * Busca etiquetas por tipo
+   * 
+   * @param {string} labelType - Tipo da etiqueta
+   * @param {Object} filters - Filtros adicionais
+   * @returns {Promise} Resposta da API
+   */
+  static getLabelsByType(_0) {
+    return __async(this, arguments, function* (labelType, filters = {}) {
+      this.validateLabelType(labelType, true);
+      return this.getLabels(__spreadValues({ label_type: labelType }, filters));
+    });
+  }
+  /**
+   * Obtém uma etiqueta específica
+   * GET /v1/label
+   * 
+   * @param {number} labelId - ID da etiqueta
+   * @returns {Promise} Resposta da API
+   */
+  static getLabel(labelId) {
+    return __async(this, null, function* () {
+      try {
+        const response = yield apiClient$1.get("/v1/label", {
+          params: { label_id: labelId }
+        });
+        if (!response.data || !response.data.labels || !response.data.labels.length) {
+          return null;
+        }
+        return response.data.labels.filter((label) => label.label_id == labelId)[0] || null;
+      } catch (error) {
+        throw new Error(`Erro ao buscar etiqueta ${labelId}: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Cria uma nova etiqueta
+   * POST /v1/label
+   * 
+   * @param {Object} labelData - Dados da etiqueta
+   * @param {string} [labelData.label_type] - Tipo da etiqueta
+   * @param {string} [labelData.label_name] - Nome da etiqueta
+   * @param {string} [labelData.label_content] - Conteúdo da etiqueta
+   * @returns {Promise} Resposta da API
+   */
+  static createLabel(labelData) {
+    return __async(this, null, function* () {
+      try {
+        if (labelData.label_type) {
+          this.validateLabelType(labelData.label_type, true);
+        }
+        const response = yield apiClient$1.post("/v1/label", labelData);
+        return response.data;
+      } catch (error) {
+        throw new Error(`Erro ao criar etiqueta: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Valida se o tipo de etiqueta é um dos tipos permitidos
+   * 
+   * @param {string} labelType - Tipo de etiqueta a ser validado
+   * @returns {boolean} True se for válido, false caso contrário
+   * @throws {Error} Se o tipo for inválido e throwError for true
+   */
+  static validateLabelType(labelType, throwError = false) {
+    const isValid = Object.values(LABEL_TYPES$1).includes(labelType);
+    if (!isValid && throwError) {
+      throw new Error(`Tipo de etiqueta inválido: "${labelType}" não é um de part, scrap, thickened, input e volume.`);
+    }
+    return isValid;
+  }
+  /**
+   * Retorna um tipo de etiqueta se for válido
+   * 
+   * @param {string} labelType - Tipo de etiqueta a verificar
+   * @returns {string} O tipo de etiqueta validado
+   * @throws {Error} Se o tipo for inválido
+   */
+  static labelByType(labelType) {
+    this.validateLabelType(labelType, true);
+    return labelType;
+  }
+  /**
+   * Atualiza uma etiqueta existente
+   * POST /v1/label (com label_id)
+   * 
+   * @param {number} labelId - ID da etiqueta
+   * @param {Object} labelData - Dados atualizados da etiqueta
+   * @returns {Promise} Resposta da API
+   */
+  static updateLabel(labelId, labelData) {
+    return __async(this, null, function* () {
+      try {
+        if (labelData.label_type) {
+          this.validateLabelType(labelData.label_type, true);
+        }
+        const response = yield apiClient$1.post("/v1/label", __spreadValues({
+          label_id: labelId
+        }, labelData));
+        return response.data;
+      } catch (error) {
+        throw new Error(`Erro ao atualizar etiqueta ${labelId}: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Remove uma etiqueta
+   * DELETE /v1/label
+   * 
+   * @param {number} labelId - ID da etiqueta
+   * @returns {Promise} Resposta da API
+   */
+  static deleteLabel(labelId) {
+    return __async(this, null, function* () {
+      try {
+        const response = yield apiClient$1.delete("/v1/label", {
+          params: { label_id: labelId }
+        });
+        return response.data;
+      } catch (error) {
+        throw new Error(`Erro ao deletar etiqueta ${labelId}: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Configura o token de autenticação
+   * 
+   * @param {string} token - Token de autenticação
+   */
+  static setAuthToken(token) {
+    apiClient$1.defaults.headers.common["Authorization"] = `${token}`;
+  }
+  /**
+   * Remove o token de autenticação
+   */
+  static removeAuthToken() {
+    delete apiClient$1.defaults.headers.common["Authorization"];
+  }
+  /**
+   * Configura a URL base da API
+   * 
+   * @param {string} baseURL - Nova URL base
+   */
+  static setBaseURL(baseURL) {
+    apiClient$1.defaults.baseURL = baseURL;
+  }
+}
 function getTemplateById(templateId) {
   return __async(this, null, function* () {
     try {
-      const labelData = yield LabelsAPI$1.getLabel(templateId);
+      const labelData = yield LabelsAPI.getLabel(templateId);
       if (!labelData) {
         throw new Error(`Template/etiqueta não encontrado com ID: ${templateId}`);
       }
@@ -58313,11 +58525,78 @@ const safeApplyTransformations = (data, fieldMap, options = {}) => {
   }
 };
 const legacyFieldMap = {
-  /**
-   * Transformação de tipo de peça por índice
-   * 0: Matéria Prima, 1: Produto Acabado, 2: Produto Intermediário
-   */
-  PECA_TIPO: ["Matéria Prima", "Produto Acabado", "Produto Intermediário"],
+  PROJETO_ID: "project_id",
+  PROJETO_NOME: "project_description",
+  PROJETO_OBS: "project_note",
+  CLIENTE_ID: "project_customer_id",
+  CLIENTE_NOME: "project_customer_name",
+  PECA_ID: "id",
+  PECA_CODIGO: "pid",
+  PECA_REF: ["pref", "ref"],
+  MODULO_REF: "mref",
+  MODULO_QTD: ["mqt", "module_quantity"],
+  PECA_INDICE: "index",
+  PECA_INDICE2: "number",
+  PECA_NOME: "name",
+  PECA_OBS: "note",
+  LARGURA: "width",
+  ALTURA: "height",
+  ESPESSURA: "thickness",
+  MN: ["materialName", "material", "material_name"],
+  MA: "material_height",
+  ML: "material_width",
+  FURO_A: "code_a",
+  FURO_B: "code_b",
+  FE: "edge_left",
+  FD: "edge_right",
+  FS: "edge_top",
+  FI: "edge_bottom",
+  PECA_TIPO: "type",
+  // vai usar o partTypes para traduzir
+  MODULO_NOME: "mname",
+  MODULO_OBS: "mnote",
+  LOTE_ID: ["group_id", "groupId"],
+  DATA_CRIACAO: ["date", "created_at"],
+  LADO_USINAGEM: "machining_side",
+  INSUMO_QTD: "qt",
+  INSUMO_PESO: "weight",
+  INSUMO_DIMENSOES: "dimensions",
+  INSUMO_MARCA: "manufacturer",
+  VOLUME_ID: "volume_id",
+  VOLUME_NOME: "volume_name",
+  SCRAP_ID: "scrapId",
+  FURO_A2: "code_a2",
+  FURO_B2: "code_b2",
+  MATERIAL_NOME: ["materialName", "material", "material_name"],
+  TAMPONAMENTO_ID: "id",
+  // Supondo que seja o mesmo que PECA_ID para tamponamento
+  TAMPONAMENTO_REF: ["pref", "ref"],
+  TAMPONAMENTO_QT: "qt",
+  TAMPONAMENTO_PESO: "weight",
+  TAMPONAMENTO_NOME: "name",
+  INSUMO_NOME: "name",
+  INSUMO_ID: "id",
+  INSUMO_REF: ["pref", "ref"],
+  INSUMO_CATEGORIA: "category",
+  INSUMO_FABRICANTE: "manufacturer",
+  RETALHO_ID: "scrapId",
+  RETALHO_INDICE: "index",
+  RETALHO_NOME: "name",
+  RETALHO_QT: "qt",
+  RETALHO_PESO: "weight",
+  RETALHO_DIMENSOES: "dimensions",
+  RETALHO_MATERIAL: ["materialName", "material", "material_name"],
+  RETALHO_ORIGEM: "origin",
+  CODIGO_A: "code_a",
+  CODIGO_B: "code_b",
+  FURO_A_SD: "hole_a_sd",
+  FURO_B_SD: "hole_b_sd",
+  FURO_TOPO: "hole_top",
+  VOLUME_PESO: "weight",
+  VOLUME_DATA: ["date", "created_at"],
+  VOLUME_DESCRICAO: "description",
+  VOLUME_PECAS: "itemList",
+  VOLUME_DIMENSOES: "dimensions",
   /**
    * Transformação de código A - adiciona '0' e remove primeiro caractere
    * Exemplo: 'A123456' -> '0123456'
@@ -59030,7 +59309,6 @@ const etiquetasAPI = {
   applyTransformations,
   legacyTransformer
 };
-const LabelsAPI = null;
 const LABEL_TYPES = {
   PART: "part",
   SCRAP: "scrap",
@@ -59065,7 +59343,7 @@ export {
   downloadFile as I,
   serializeXML as J,
   createBuffer as K,
-  LabelsAPI as L,
+  LABEL_TYPES as L,
   base64Encode as M,
   base64Decode as N,
   processLabelForParts as O,
@@ -59081,7 +59359,7 @@ export {
   getBorderColor as Y,
   makeLamination as Z,
   _typeof as _,
-  LABEL_TYPES as a,
+  apiClient as a,
   getAspectRatio as a0,
   DEFAULT_LAMINATION_COLORS as a1,
   stopCreatingLabels as a2,
@@ -59093,24 +59371,24 @@ export {
   generateTableSVG as a8,
   dataTypeList as a9,
   getInputsByCategory as aa,
-  apiClient as b,
+  getPartLabels as b,
   commonjsGlobal as c,
-  getPartLabels as d,
-  getScrapLabels as e,
-  getThickenedLabels as f,
+  getScrapLabels as d,
+  getThickenedLabels as e,
+  getInputLabels as f,
   getDefaultExportFromCjs as g,
-  getInputLabels as h,
-  getVolumeLabels as i,
-  LabelWorker as j,
-  createLabelWorker as k,
-  generateLabelsFromHookData as l,
-  useLabelStore as m,
-  getPartsForLabels as n,
-  getInputForLabels as o,
-  getPartsFromProjectToLabels as p,
-  labelTypeNames as q,
-  initialState as r,
-  reducer as s,
+  getVolumeLabels as h,
+  LabelWorker as i,
+  createLabelWorker as j,
+  generateLabelsFromHookData as k,
+  useLabelStore as l,
+  getPartsForLabels as m,
+  getInputForLabels as n,
+  getPartsFromProjectToLabels as o,
+  labelTypeNames as p,
+  initialState as q,
+  reducer as r,
+  LabelsAPI as s,
   init as t,
   useLabelData as u,
   getPrinterStatus as v,
@@ -59119,4 +59397,4 @@ export {
   downloadPDF as y,
   sendToPrinter as z
 };
-//# sourceMappingURL=index-BkmabrFq.js.map
+//# sourceMappingURL=index-B10y8IWE.js.map