Biblioteca Poderosa de Processamento de Texto Open-Source para Go

Começando com wordZero

A forma recomendada de instalar o wordZero em seu projeto é usando o GitHub. Por favor, use o comando a seguir para uma instalação tranquila.

go get github.com/zerx-lab/wordZero

Criar e Salvar Documentos Word via API Go

Uma das principais capacidades do wordZero é sua habilidade de criar documentos Word do zero. Os desenvolvedores podem inicializar um novo documento, adicionar conteúdo e salvá-lo como um arquivo DOCX em poucas linhas de código. Esse recurso é extremamente útil para sistemas de relatórios automatizados, serviços de geração de documentos e aplicações que precisam exportar dados do usuário para o formato Microsoft Word. Como a biblioteca lida com o empacotamento OOXML internamente, os desenvolvedores podem focar na criação de conteúdo ao invés de lidar com estruturas complexas de documentos.

package main

import  ( 
	"github.com/ZeroHawkeye/wordZero/pkg/document" 
)

func main() { 
	doc := document.New() 
	
	doc.AddParagraph("Welcome to wordZero!") 
	
	err := doc.Save("sample.docx")
	 if err != nil {
	 panic(err) 
	}
  }
 

Engine de Templates Avançado com Herança

O motor de templates do WordZero transforma a forma como você gera documentos dinâmicos. Ao contrário da substituição básica de strings, ele suporta herança baseada em blocos, renderização condicional, loops e placeholders de imagens. Isso significa que você pode criar templates base (cabeçalhos, rodapés, diretrizes de marca) e estendê-los para casos de uso específicos, como relatórios de vendas ou faturas. É muito útil para eliminar a duplicação de código e separar o conteúdo da apresentação. As equipes de marketing podem atualizar os templates sem a intervenção de desenvolvedores.

package main

import (
    "log"
    "github.com/zerx-lab/wordZero/pkg/document"
)

func main() {
    engine := document.NewTemplateEngine()
    
    // Base template with reusable blocks
    baseTemplate := `{{companyName}} Report
{{#block "summary"}}Default summary{{/block}}
{{#block "content"}}Default content{{/block}}`
    
    engine.LoadTemplate("base", baseTemplate)
    
    // Child template overriding specific blocks
    salesTemplate := `{{extends "base"}}
{{#block "summary"}}
Sales: {{revenue}} USD | Growth: {{growth}}%
{{/block}}`
    
    engine.LoadTemplate("sales", salesTemplate)
    
    data := document.NewTemplateData()
    data.SetVariable("companyName", "Acme Corp")
    data.SetVariable("revenue", "125000")
    data.SetVariable("growth", "15")
    
    doc, _ := engine.RenderTemplateToDocument("sales", data)
    doc.Save("quarterly_report.docx")
}
 

Gerenciamento Dinâmico de Imagens Nativas e Escalonamento Automático

Integrar recursos como gráficos, identidade visual da organização ou fotografias requer gerenciamento rigoroso de layout para evitar estragar a quebra de texto. A biblioteca de código aberto wordZero oferece wrappers nativos simples que aceitam entradas de imagem diretamente de caminhos de sistema físicos ou de arrays de bytes em memória ([]byte). A biblioteca detecta automaticamente as proporções, permitindo funções como ajuste automático de imagens às margens ou restrições explícitas de pixels.

package main

import (
	"log"
	"github.com/zerx-lab/wordZero/pkg/document"
)

func main() {
	doc := document.New()
	doc.AddParagraph("Visual Asset Documentation Summary")

	// Insert an image path from your local deployment setup
	image, err := doc.AddImageFromFile("company_logo.png")
	if err != nil {
		log.Fatalf("Unable to discover or parse local asset: %v", err)
	}

	// Constrain the target image properties while auto-fitting column margins safely
	image.SetWidth(350)
	image.FitToPageWidth()

	if err := doc.Save("image_report.docx"); err != nil {
		log.Fatalf("Error saving file payload: %v", err)
	}
}

Conversões Diretas de Markdown para Word via Biblioteca Ruby?

Em pipelines de publicação descentralizadas, o Markdown costuma ser a escolha preferida para escrever conteúdo, enquanto o Word é necessário para distribuição corporativa. O wordZero atende a essa necessidade com um módulo de conversão duplo dedicado e incorporado. Ele analisa cabeçalhos padrão, parâmetros embutidos (negrito, itálico, tags de código), listas e links diretamente de blocos de origem Markdown básicos, traduzindo-os de forma limpa para árvores de documentos OOXML profissionais.

package main

import (
	"log"
	"github.com/zerx-lab/wordZero/pkg/markdown"
)

func main() {
	// Initialize a standard options Markdown converter block
	converter := markdown.NewConverter(markdown.DefaultOptions())

	// Define raw text variables highlighting structured Markdown elements
	markdownContent := `
# Project Documentation
Welcome to automated generation.
## Features Included
- **High-Performance Compilation** via native Go routines.
- Clean nested element styling hooks.`

	// Process raw strings directly into a formatted .docx file
	err := converter.ConvertStringToFile(markdownContent, "markdown_transformed.docx")
	if err != nil {
		log.Fatalf("Markdown parsing pipeline encounter error: %v", err)
	}
}