psrt.core

psrt.core

Implementação canônica em Go do PSRT — um formato de documento linear e textual para sobrepor textos (traduções, legendas, créditos) em páginas de imagem, como mangás, webtoons e capas de livros.

Este repositório é o core do ecossistema PSRT: a biblioteca de parse/serialização, os compiladores para SVG e HTML, as ferramentas de linha de comando, o editor desktop e a ponte WASM usada pelo SDK JavaScript.

Índice

• O que é o PSRT
• O que tem neste repositório
• Instalação
• Uso rápido
• Usando a biblioteca em Go
• Arquitetura
• Testes
• Ecossistema PSRT
• Contribuindo
• Licença

O que é o PSRT

Quem traduz ou revisa conteúdo visual — quadrinhos, webtoons, capas — geralmente precisa reposicionar texto sobre uma imagem já existente sem alterar a imagem em si. O PSRT resolve isso com um arquivo de texto simples (.psrt) que descreve, por página:

• a imagem de fundo;
• blocos de texto posicionados em percentual (X-Y-Width-TextSize);
• estilo de cada bloco em JSON inline (cor, fonte, sombra, borda, alinhamento);
• fontes e constantes reutilizáveis ($FONTS, $CONSTS, @nome@).

O nome vem da analogia com legendas .srt: assim como um .srt sincroniza texto com vídeo, o .psrt sincroniza texto com uma imagem — "Picture SRT".

Por ser texto puro, um .psrt é versionável em Git, revisável em PR, e editável tanto à mão quanto por ferramentas. A partir dele, este repositório compila para dois formatos de leitura universal:

Exemplo mínimo de um .psrt:

$START pagina1 | {"backGround":"#000000"} | https://example.com/page1.png
>>50-50-80-2 | {"color":"#FFFFFF","textAlign":"center"} | 0
Texto centralizado
$END pagina1

O que tem neste repositório

Comandos (cmd/)

Instalação

Requer Go 1.22+.

git clone https://github.com/Dcrispim/psrt.core.git
cd psrt.core
go build ./...

Para um binário específico, por exemplo o conversor psrt:

go build -o psrt.exe ./cmd/cli

Uso rápido

# PSRT -> JSON
go run ./cmd/cli --input=exemplo.psrt --output=exemplo.json

# PSRT -> HTML autocontido (offline, assets embutidos)
go run ./cmd/compile --input=exemplo.psrt --output=exemplo.html

# PSRT -> SVG (um arquivo por página)
go run ./cmd/compile-svg --input=exemplo.psrt --output-dir=./out-svg

# Editar um bloco de texto pela CLI
go run ./cmd/psrt-edit --input=exemplo.psrt --page=pagina1 --text=0 --content="Novo texto"

Usando a biblioteca em Go

package main

import (
	"fmt"
	"os"

	"github.com/Dcrispim/psrt.core/psrt"
)

func main() {
	f, err := os.Open("exemplo.psrt")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	doc, err := psrt.Parse(f)
	if err != nil {
		panic(err)
	}

	// Document -> JSON
	out, err := psrt.ToJSON(doc)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(out))

	// Document -> PSRT (round-trip)
	restored, err := psrt.FormatPSRT(doc, false)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(restored))
}

go get github.com/Dcrispim/psrt.core/psrt

Arquitetura

flowchart LR
  PSRT[".psrt"] --> Parse["psrt.Parse"]
  Parse --> Doc["Document"]
  Doc --> Editor["psrt/editor"]
  Doc --> CompileSVG["compilesvg"]
  Doc --> CompileHTML["compilehtml"]
  CompileSVG --> Asset["compileasset"]
  CompileHTML --> Asset
  Asset --> Style["styleadapter"]
  CompileSVG --> SVG[".svg por página"]
  CompileHTML --> HTML[".html autocontido"]
  Doc --> Wasm["wasmbridge (WASM)"]

1. Parse — psrt.Parse lê o .psrt e produz um Document em memória.
2. Edição — psrt/editor ou o backend do psrt-gui mutam o Document.
3. Serialização — psrt.FormatPSRT (volta para texto) ou psrt.ToJSON.
4. Compilação — compilesvg/compilehtml resolvem constantes, buscam assets via compileasset, adaptam estilos via styleadapter e geram a saída final.

Testes

go test ./...

Ecossistema PSRT

Este repositório é a peça central, mas o PSRT também tem:

• SDK JavaScript (@psrt/sdk) — TypeScript + WASM compilado a partir de cmd/psrt-wasm/internal/wasmbridge, para ler e renderizar PSRT no browser.
• Editor web — frontend que usa o SDK e, opcionalmente, o psrt-web-connector para acessar arquivos locais.

Contribuindo

Contribuições são bem-vindas — issues, relatos de bugs e pull requests.

1. Abra uma issue descrevendo o problema ou a proposta antes de PRs grandes.
2. Mantenha mudanças focadas; adicione testes (go test ./...) para parsing, formatação e compiladores.
3. Siga o estilo já presente no código (gofmt/go vet antes de enviar).

Licença

Distribuído sob a licença MIT.