tstlai

npm install tstlai

import { Tstlai } from 'tstlai';

async function main() {
  // 1. Initialize the Engine
  const translator = new Tstlai({
    targetLang: 'es', // Target language code
    provider: {
      type: 'openai',
      // apiKey, model, and baseUrl can be omitted if set via env vars:
      // OPENAI_API_KEY, OPENAI_MODEL, OPENAI_BASE_URL
    },
    cache: {
      type: 'memory',
      ttl: 3600 // Cache duration in seconds
    }
  });

  // 2. Your raw HTML content
  const rawHtml = `
    <article>
      <h1>Welcome to the Future</h1>
      <p>Translate your website instantly.</p>
      <button data-no-translate>tstlai v1.0</button>
    </article>
  `;

  // 3. Process the HTML
  const result = await translator.process(rawHtml);
  console.log(result.html);
}

main();

<article>
  <h1>Bienvenido al Futuro</h1>
  <p>Traduce tu sitio web al instante.</p>
  <button data-no-translate>tstlai v1.0</button>
</article>

import express from 'express';
import { Tstlai, integrations } from 'tstlai';

const app = express();
const translator = new Tstlai({
  targetLang: 'es',
  provider: { type: 'openai' }
});

// Apply middleware
app.use(integrations.createExpressMiddleware(translator));

app.get('/', (req, res) => {
  res.send('<h1>Hello World</h1>');
  // Automatically translated to <h1>Hola Mundo</h1>
});

// src/lib/translator.ts
import { Tstlai } from 'tstlai';

const translators = new Map<string, Tstlai>();

export function getTranslator(locale: string): Tstlai {
  if (!translators.has(locale)) {
    translators.set(locale, new Tstlai({
      targetLang: locale,
      sourceLang: 'en',
      provider: { type: 'openai' },
      cache: { type: 'redis' } // or 'memory'
    }));
  }
  return translators.get(locale)!;
}

// src/app/api/tstlai/translate/route.ts
import { createNextRouteHandler } from 'tstlai/next';
import { getTranslator } from '@/lib/translator';

export const POST = async (req: Request) => {
  const { targetLang } = await req.json();
  const handler = createNextRouteHandler(getTranslator(targetLang));
  return handler(new Request(req.url, {
    method: 'POST',
    headers: req.headers,
    body: JSON.stringify({ targetLang }),
  }));
};

// src/app/[locale]/layout.tsx
import { AutoTranslate } from 'tstlai/next';

export default async function LocaleLayout({ children, params }) {
  const { locale } = await params;
  return (
    <>
      {children}
      {locale !== 'en' && <AutoTranslate targetLang={locale} />}
    </>
  );
}

// That's it! Your pages stay exactly as they are.
// English renders normally, other locales auto-translate.

// src/i18n.ts
import { Tstlai, integrations } from 'tstlai';
import enMessages from '../messages/en.json';

const translator = new Tstlai({
  targetLang: 'en',
  provider: { type: 'openai' }
});

export const { getTranslations } = integrations.createNextIntlAdapter(
  translator, 
  enMessages
);

// In Server Components (just like next-intl):
import { getTranslations } from '@/i18n';

export default async function Page({ params: { locale } }) {
  const t = await getTranslations(locale);
  return <h1>{t('landing.hero.title')}</h1>;
}

const translator = new Tstlai({
  // ...
  cache: {
    type: 'redis',
    connectionString: 'redis://localhost:6379',
    ttl: 86400, // 24 hours
    keyPrefix: 'tstlai:' // Default namespace
  }
});

// Multi-language cache keys: tstlai:<hash>:<lang>
// Translations for different languages are stored separately

<span data-no-translate>BrandName™</span>

# Generate Spanish translations from English source
npx tstlai generate --source messages/en.json --target es --output messages/es.json

# Generate multiple locales
npx tstlai generate --source messages/en.json --target es,fr,de --output messages/

// In your messages/en.json
{
  "actions": {
    "save": "$t/Save/$ctx/button to store data",
    "post": "$t/Post/$ctx/publish content to feed"
  },
  "sports": {
    "match": "$t/Match/$ctx/sports competition game"
  }
}

// Or use the translateText() API with context
await translator.translateText("Save", { context: "button to store data" });
await translator.translateText("Match", { context: "sports competition" });

import { isLanguageSupported, SHORT_CODE_DEFAULTS } from 'tstlai';

// Use short codes for browser negotiation
const NEGOTIATION_LOCALES = Object.keys(SHORT_CODE_DEFAULTS);

// In your middleware
if (!isLanguageSupported(locale)) {
  return NextResponse.redirect(new URL('/en' + pathname, request.url));
}

<AutoTranslate 
  targetLang={locale} 
  stream={true}
  streamEndpoint="/api/tstlai/stream"
  streamBuffer={500} // Buffer first 500ms for smoother initial render
/>

// src/app/api/tstlai/stream/route.ts
import { createNextStreamingRouteHandler } from 'tstlai/next';
import { getTranslator } from '@/lib/translator';

export const POST = async (req: Request) => {
  const { targetLang } = await req.json();
  const handler = createNextStreamingRouteHandler(getTranslator(targetLang));
  return handler(req);
};