@brianfunk/capita 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Brian Funk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+[![cAPIta](https://img.shields.io/badge/cAPIta-CaPiTaLiZaTiOn%20API-b5d4ff.svg)](https://github.com/brianfunk/cAPIta)
+[![npm version](https://img.shields.io/npm/v/@brianfunk/capita.svg)](https://www.npmjs.com/package/@brianfunk/capita)
+[![npm downloads](https://img.shields.io/npm/dm/@brianfunk/capita.svg)](https://www.npmjs.com/package/@brianfunk/capita)
+[![Netlify](https://img.shields.io/badge/live-capita-api.netlify.app-b5d4ff.svg)](https://capita-api.netlify.app)
+[![CI](https://github.com/brianfunk/cAPIta/actions/workflows/ci.yml/badge.svg)](https://github.com/brianfunk/cAPIta/actions/workflows/ci.yml)
+[![Open Source Love](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badge/)
+[![Semver](https://img.shields.io/badge/SemVer-2.0-blue.svg)](http://semver.org/spec/v2.0.0.html)
+[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://opensource.org/licenses/MIT)
+[![LinkedIn](https://img.shields.io/badge/Linked-In-blue.svg)](https://www.linkedin.com/in/brianrandyfunk)
+
+# cAPIta
+
+> cAPIta - Capitalization API
+
+A blazing-fast REST API for text transformation. Convert any string to 29 different styles including camelCase, snake_case, kebab-case, and more! Powered by [capstring](https://github.com/brianfunk/capstring).
+
+## Try It Live
+
+**https://capita-api.netlify.app** has a playground that transforms as you type. Or just hit a URL:
+
+- https://capita-api.netlify.app/sponge/hello%20world.txt → `HeLlO WoRlD`
+- https://capita-api.netlify.app/kebab/Hello%20World.json → `{"input":"Hello World","output":"hello-world","cap":"kebab"}`
+- https://capita-api.netlify.app/badge/upper/hello → an SVG badge for your README
+- https://capita-api.netlify.app/spell/helo%20wrld.txt → `hello world`
+
+## Why cAPIta?
+
+- **29 capitalization styles** - More than any other text transform API!
+- **Multiple output formats** - JSON, JSONP, HTML, TXT, XML, YAML, CSV
+- **Built-in spell check** - Powered by nspell (no API key required!)
+- **Batch processing** - Transform up to 100 strings at once
+- **Chain transformations** - Apply multiple styles in sequence
+- **Word/char count** - Built-in text analytics
+- **Lorem ipsum generator** - Generate placeholder text
+- **XSS-safe HTML output** - Security built in
+- **Content negotiation** - Automatic format based on Accept header
+
+## Quick Start
+
+```bash
+# Run it (no install needed)
+npx @brianfunk/capita
+
+# Or clone and start
+npm install
+npm start
+
+# Try it out!
+curl http://localhost:4321/title/hello%20world.json
+# {"input":"hello world","output":"Hello World","cap":"title"}
+
+# See all available styles
+curl http://localhost:4321/styles
+```
+
+## API Endpoints
+
+### Transform Text
+
+```
+GET /:style/:string
+GET /:style/:string.:ext
+```
+
+### Chain Multiple Transformations
+
+```
+GET /chain/:styles/:string
+```
+
+Chain styles with `+`:
+
+```bash
+curl http://localhost:4321/chain/upper+reverse/hello.json
+# {"input":"hello","output":"OLLEH","cap":"upper+reverse"}
+
+curl http://localhost:4321/chain/lower+title+kebab/HELLO%20WORLD.txt
+# hello-world
+```
+
+### Batch Processing
+
+```
+POST /batch
+```
+
+Transform multiple strings at once:
+
+```bash
+curl -X POST http://localhost:4321/batch \
+  -H "Content-Type: application/json" \
+  -d '{"inputs": ["hello", "world"], "style": "upper"}'
+# {"style":"upper","results":[{"input":"hello","output":"HELLO"},{"input":"world","output":"WORLD"}],"count":2}
+```
+
+### Word/Character Count
+
+```
+GET /count/:string
+GET /count/:string.:ext
+```
+
+```bash
+curl http://localhost:4321/count/hello%20world.json
+# {"input":"hello world","words":2,"characters":11,"charactersNoSpaces":10}
+```
+
+### Lorem Ipsum Generator
+
+```
+GET /lorem/:count?
+GET /lorem/:count?.:ext
+```
+
+```bash
+curl http://localhost:4321/lorem/10.json
+# {"lorem":"Lorem ipsum dolor sit amet consectetur adipiscing elit sed do.","wordCount":10}
+```
+
+### All 29 Capitalization Styles
+
+#### Case Styles
+| Style | Input | Output |
+|-------|-------|--------|
+| `upper` | hello world | HELLO WORLD |
+| `lower` | HELLO WORLD | hello world |
+| `title` | hello world | Hello World |
+| `sentence` | hello world | Hello world |
+| `swap` | Hello World | hELLO wORLD |
+
+#### Code Styles
+| Style | Input | Output |
+|-------|-------|--------|
+| `camel` | hello world | helloWorld |
+| `pascal` | hello world | HelloWorld |
+| `snake` | hello world | hello_world |
+| `kebab` | hello world | hello-world |
+| `constant` | hello world | HELLO_WORLD |
+| `dot` | hello world | hello.world |
+| `path` | hello world | hello/world |
+| `train` | hello world | Hello-World |
+
+#### Fun Styles
+| Style | Input | Output |
+|-------|-------|--------|
+| `leet` | elite | 3£1t3 |
+| `reverse` | hello | olleh |
+| `sponge` | hello | HeLlO |
+| `hashtag` | hello world | #HelloWorld |
+| `acronym` | as soon as possible | ASAP |
+| `rot13` | hello | uryyb |
+| `flip` | hello | ollǝɥ |
+
+### Output Formats
+
+| Extension | Content-Type | Example |
+|-----------|--------------|---------|
+| `.json` | application/json | `{"input":"hello","output":"HELLO","cap":"upper"}` |
+| `.jsonp` | application/javascript | Callback wrapper |
+| `.html` | text/html | `<em>HELLO</em>` |
+| `.txt` | text/plain | `HELLO` |
+| `.xml` | application/xml | `<result><output>HELLO</output></result>` |
+| `.yaml` | text/yaml | `output: "HELLO"` |
+| `.csv` | text/csv | `input,output,cap` |
+
+### Spell Check
+
+```
+GET /spell/:string
+GET /spell/:string.:ext
+```
+
+Uses [nspell](https://github.com/wooorm/nspell) with the English Hunspell dictionary. No API key required!
+
+```bash
+curl http://localhost:4321/spell/helo%20wrld.json
+# {"input":"helo wrld","output":"hello world","cap":"spell"}
+```
+
+### Generate Badges
+
+```
+GET /badge/:style/:string
+```
+
+Returns a shields-style SVG badge, rendered locally with no external calls. Perfect for README files!
+
+### List Available Styles
+
+```
+GET /styles
+```
+
+Returns all available styles and their count.
+
+## Configuration
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `PORT` | Server port | `4321` |
+
+## Security
+
+- **XSS Prevention** - HTML output is escaped
+- **Input Limits** - Max 10,000 characters per request
+- **Batch Limits** - Max 100 items per batch request
+- **Chain Limits** - Max 10 transformations per chain
+
+## Development
+
+```bash
+npm install        # Install dependencies
+npm start          # Start server
+npm run dev        # Run through Netlify Dev (static playground + function)
+npm run demo       # Run interactive demo
+npm test           # Run tests
+npm run lint       # Run linter
+npm run test:coverage # Test with coverage (84%+)
+```
+
+## Deployment
+
+The site runs on Netlify: `public/` is served statically (the playground) and every other path is redirected to `netlify/functions/api.mjs`, which wraps the Express app. See `netlify.toml`.
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the process for submitting pull requests.
+
+## Versioning
+
+This project uses [Semantic Versioning 2.0](http://semver.org/spec/v2.0.0.html).
+
+## Related Projects
+
+- **[capstring](https://github.com/brianfunk/capstring)** - The core library that powers cAPIta
+
+## Requirements
+
+- Node.js 18+
+- ES modules (`import`/`export`)
+
+## License
+
+MIT

package/app.js

@@ -0,0 +1,445 @@
+/*
+          _    ____ ___ _
+   ___   / \  |  _ \_ _| |_ __ _
+  / __| / _ \ | |_) | || __/ _` |
+ | (__ / ___ \|  __/| || || (_| |
+  \___/_/   \_\_|  |___|\__\__,_|
+
+*/
+
+/**
+ * cAPIta - Capitalization API
+ * Express app factory powered by capstring. See index.js for the server entry.
+ * @module cAPIta
+ */
+
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import express from 'express';
+import capstring, { STYLES, isValidStyle } from 'capstring';
+import nspell from 'nspell';
+import dictionary from 'dictionary-en';
+
+/** Directory holding the static playground */
+const PUBLIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'public');
+
+/** Maximum input length to prevent abuse */
+const MAX_INPUT_LENGTH = 10000;
+
+/** Supported output formats */
+const EXTS = Object.freeze(['json', 'jsonp', 'html', 'txt', 'xml', 'yaml', 'yml', 'csv']);
+
+/** Lorem Ipsum base text */
+const LOREM_WORDS = 'lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est laborum'.split(' ');
+
+/** @type {import('nspell').default|null} */
+let spellChecker = null;
+
+/**
+ * Initialize the spell checker with the English dictionary
+ */
+const initSpellChecker = () => {
+  if (spellChecker) return;
+  spellChecker = nspell(dictionary);
+};
+
+/**
+ * Escape HTML special characters to prevent XSS
+ * @param {string} str - The string to escape
+ * @returns {string} The escaped string
+ */
+const escapeHtml = (str) => {
+  const htmlEscapes = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+};
+
+/**
+ * Render a shields.io-style flat SVG badge locally (no network call)
+ * @param {string} label - Left-hand label text
+ * @param {string} value - Right-hand value text
+ * @returns {string} SVG markup
+ */
+const badgeSvg = (label, value) => {
+  const charWidth = 6.5;
+  const padding = 10;
+  const labelWidth = Math.round(label.length * charWidth + padding);
+  const valueWidth = Math.round(value.length * charWidth + padding);
+  const width = labelWidth + valueWidth;
+  const safeLabel = escapeHtml(label);
+  const safeValue = escapeHtml(value);
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="20" role="img" aria-label="${safeLabel}: ${safeValue}">
+  <title>${safeLabel}: ${safeValue}</title>
+  <linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient>
+  <clipPath id="r"><rect width="${width}" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${labelWidth}" height="20" fill="#555"/>
+    <rect x="${labelWidth}" width="${valueWidth}" height="20" fill="#b5d4ff"/>
+    <rect width="${width}" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="${labelWidth / 2}" y="15" fill="#010101" fill-opacity=".3">${safeLabel}</text>
+    <text x="${labelWidth / 2}" y="14">${safeLabel}</text>
+    <text x="${labelWidth + valueWidth / 2}" y="15" fill="#010101" fill-opacity=".3">${safeValue}</text>
+    <text x="${labelWidth + valueWidth / 2}" y="14" fill="#333">${safeValue}</text>
+  </g>
+</svg>`;
+};
+
+/**
+ * Spell check and correct text using nspell
+ * @param {string} text - Text to spell check
+ * @returns {string} Corrected text
+ */
+const spellCheckText = (text) => {
+  initSpellChecker();
+
+  // Split into words while preserving spacing and punctuation
+  const words = text.split(/(\s+)/);
+
+  const corrected = words.map((word) => {
+    // Skip whitespace
+    if (/^\s*$/.test(word)) return word;
+
+    // Extract punctuation from word
+    const match = word.match(/^([^a-zA-Z]*)([a-zA-Z]+)([^a-zA-Z]*)$/);
+    if (!match) return word;
+
+    const [, prefix, core, suffix] = match;
+
+    // Check if word is spelled correctly
+    if (spellChecker.correct(core)) {
+      return word;
+    }
+
+    // Get suggestions
+    const suggestions = spellChecker.suggest(core);
+    if (suggestions.length > 0) {
+      return prefix + suggestions[0] + suffix;
+    }
+
+    return word;
+  });
+
+  return corrected.join('');
+};
+
+/**
+ * Format and send response based on extension/content type
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {string} input - Original input
+ * @param {string} output - Transformed output
+ * @param {string} cap - Capitalization type
+ * @param {string|false} ext - File extension or false for content negotiation
+ */
+const outResponse = (req, res, input, output, cap, ext) => {
+  const safeOutput = escapeHtml(output);
+  const outHtml = `<head><title></title></head><body><p><strong><em>${safeOutput}</em></strong></p></body>`;
+  const outJson = { input, output, cap };
+
+  if (ext) {
+    if (!EXTS.includes(ext)) {
+      res.status(400).send('error - invalid ext');
+      return;
+    }
+
+    switch (ext) {
+      case 'txt':
+        res.type('text');
+        res.send(output);
+        break;
+      case 'html':
+        res.type('html');
+        res.send(outHtml);
+        break;
+      case 'json':
+        res.json(outJson);
+        break;
+      case 'jsonp':
+        res.jsonp(outJson);
+        break;
+      case 'xml':
+        res.type('application/xml');
+        res.send(`<?xml version="1.0" encoding="UTF-8"?>\n<result>\n  <input>${escapeHtml(input)}</input>\n  <output>${safeOutput}</output>\n  <cap>${cap}</cap>\n</result>`);
+        break;
+      case 'yaml':
+      case 'yml': {
+        res.type('text/yaml');
+        // YAML escape: handle quotes, newlines, special chars
+        const yamlEscape = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+        res.send(`input: "${yamlEscape(input)}"\noutput: "${yamlEscape(output)}"\ncap: "${cap}"`);
+        break;
+      }
+      case 'csv': {
+        res.type('text/csv');
+        // CSV escape: double quotes and handle newlines (wrap in quotes)
+        const csvEscape = (s) => s.replace(/"/g, '""').replace(/[\r\n]/g, ' ');
+        res.send(`input,output,cap\n"${csvEscape(input)}","${csvEscape(output)}","${cap}"`);
+        break;
+      }
+    }
+  } else {
+    res.format({
+      text: () => res.send(output),
+      html: () => res.send(outHtml),
+      json: () => res.json(outJson),
+      jsonp: () => res.jsonp(outJson)
+    });
+  }
+};
+
+/**
+ * Create and configure the Express app
+ * @returns {express.Application} Configured Express app
+ */
+export const createApp = () => {
+  const app = express();
+
+  app.use(express.json());
+
+  // Playground (public/index.html) and any other static assets
+  app.use(express.static(PUBLIC_DIR));
+
+  // List available styles
+  app.get('/styles', (_req, res) => {
+    res.json({
+      styles: STYLES,
+      count: STYLES.length
+    });
+  });
+
+  // Badge route
+  app.get('/badge/:cap/:string', (req, res) => {
+    const { cap, string } = req.params;
+
+    if (!isValidStyle(cap)) {
+      res.status(400).send('error - invalid case');
+      return;
+    }
+
+    if (string.length > MAX_INPUT_LENGTH) {
+      res.status(400).send('error - input too long');
+      return;
+    }
+
+    const cs = capstring(string, cap);
+    res.type('image/svg+xml');
+    res.send(badgeSvg(`cAPIta ${capstring(cap, cap)}`, cs));
+  });
+
+  // Word and character count
+  app.get('/count/:string.:ext?', (req, res) => {
+    const { string, ext } = req.params;
+
+    if (string.length > MAX_INPUT_LENGTH) {
+      res.status(400).send('error - input too long');
+      return;
+    }
+
+    const words = string.trim().split(/\s+/).filter(w => w.length > 0);
+    const chars = string.length;
+    const charsNoSpaces = string.replace(/\s/g, '').length;
+
+    const result = {
+      input: string,
+      words: words.length,
+      characters: chars,
+      charactersNoSpaces: charsNoSpaces
+    };
+
+    if (ext === 'json' || !ext) {
+      res.json(result);
+    } else if (ext === 'txt') {
+      res.type('text');
+      res.send(`words: ${words.length}, chars: ${chars}, chars (no spaces): ${charsNoSpaces}`);
+    } else if (ext === 'html') {
+      const safeInput = escapeHtml(string);
+      res.type('html');
+      res.send(`<head><title>Count</title></head><body><p>Input: <em>${safeInput}</em></p><p>Words: ${words.length}</p><p>Characters: ${chars}</p><p>Characters (no spaces): ${charsNoSpaces}</p></body>`);
+    } else {
+      res.status(400).send('error - invalid ext');
+    }
+  });
+
+  // Lorem ipsum generator
+  app.get('/lorem/:count?.:ext?', (req, res) => {
+    const parsedCount = parseInt(req.params.count, 10);
+    const count = isNaN(parsedCount) ? 50 : parsedCount;
+    const { ext } = req.params;
+
+    if (count < 1 || count > 1000) {
+      res.status(400).send('error - count must be 1-1000');
+      return;
+    }
+
+    // Generate lorem ipsum words
+    const words = [];
+    for (let i = 0; i < count; i++) {
+      words.push(LOREM_WORDS[i % LOREM_WORDS.length]);
+    }
+    // Capitalize first word
+    words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1);
+
+    const lorem = words.join(' ') + '.';
+
+    if (ext === 'json' || !ext) {
+      res.json({ lorem, wordCount: count });
+    } else if (ext === 'txt') {
+      res.type('text');
+      res.send(lorem);
+    } else if (ext === 'html') {
+      res.type('html');
+      res.send(`<head><title>Lorem Ipsum</title></head><body><p>${lorem}</p></body>`);
+    } else {
+      res.status(400).send('error - invalid ext');
+    }
+  });
+
+  // Batch/bulk transformation (POST)
+  app.post('/batch', (req, res) => {
+    const { inputs, style } = req.body;
+
+    if (!Array.isArray(inputs)) {
+      res.status(400).json({ error: 'inputs must be an array' });
+      return;
+    }
+
+    if (inputs.length > 100) {
+      res.status(400).json({ error: 'maximum 100 inputs per batch' });
+      return;
+    }
+
+    if (!isValidStyle(style)) {
+      res.status(400).json({ error: 'invalid style', validStyles: [...STYLES] });
+      return;
+    }
+
+    const results = inputs.map(input => {
+      if (typeof input !== 'string') {
+        return { input, output: null, error: 'input must be string' };
+      }
+      if (input.length > MAX_INPUT_LENGTH) {
+        return { input: input.slice(0, 50) + '...', output: null, error: 'input too long' };
+      }
+      const output = capstring(input, style);
+      return { input, output };
+    });
+
+    res.json({ style, results, count: results.length });
+  });
+
+  // Chain multiple transformations
+  app.get('/chain/:styles/:string.:ext?', (req, res) => {
+    const { styles, string, ext } = req.params;
+
+    if (string.length > MAX_INPUT_LENGTH) {
+      res.status(400).send('error - input too long');
+      return;
+    }
+
+    const styleList = styles.split('+');
+    if (styleList.length > 10) {
+      res.status(400).send('error - maximum 10 chained styles');
+      return;
+    }
+
+    for (const s of styleList) {
+      if (!isValidStyle(s)) {
+        res.status(400).send(`error - invalid style: ${s}`);
+        return;
+      }
+    }
+
+    let result = string;
+    for (const s of styleList) {
+      result = capstring(result, s);
+      if (result === false) {
+        res.status(400).send('error - transformation failed');
+        return;
+      }
+    }
+
+    outResponse(req, res, string, result, styleList.join('+'), ext || false);
+  });
+
+  // Spell check with extension
+  app.get('/spell/:string.:ext', (req, res) => {
+    const { string, ext } = req.params;
+
+    try {
+      const cs = spellCheckText(string);
+      outResponse(req, res, string, cs, 'spell', ext);
+    } catch {
+      res.status(500).send('error - spell check failed');
+    }
+  });
+
+  // Spell check without extension
+  app.get('/spell/:string', (req, res) => {
+    const { string } = req.params;
+
+    try {
+      const cs = spellCheckText(string);
+      outResponse(req, res, string, cs, 'spell', false);
+    } catch {
+      res.status(500).send('error - spell check failed');
+    }
+  });
+
+  // Capitalize with extension
+  app.get('/:cap/:string.:ext', (req, res) => {
+    const { cap, string, ext } = req.params;
+
+    if (!isValidStyle(cap)) {
+      res.status(400).send('error - invalid case');
+      return;
+    }
+
+    if (string.length > MAX_INPUT_LENGTH) {
+      res.status(400).send('error - input too long');
+      return;
+    }
+
+    const cs = capstring(string, cap);
+    if (!cs && cap !== 'none') {
+      res.status(400).send('error - invalid string');
+      return;
+    }
+
+    outResponse(req, res, string, cs, cap, ext);
+  });
+
+  // Capitalize without extension
+  app.get('/:cap/:string', (req, res) => {
+    const { cap, string } = req.params;
+
+    if (!isValidStyle(cap)) {
+      res.status(400).send('error - invalid case');
+      return;
+    }
+
+    if (string.length > MAX_INPUT_LENGTH) {
+      res.status(400).send('error - input too long');
+      return;
+    }
+
+    const cs = capstring(string, cap);
+    if (!cs && cap !== 'none') {
+      res.status(400).send('error - invalid string');
+      return;
+    }
+
+    outResponse(req, res, string, cs, cap, false);
+  });
+
+  return app;
+};
+
+export { STYLES as CASES };
+export default createApp;

package/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/*
+          _    ____ ___ _
+   ___   / \  |  _ \_ _| |_ __ _
+  / __| / _ \ | |_) | || __/ _` |
+ | (__ / ___ \|  __/| || || (_| |
+  \___/_/   \_\_|  |___|\__\__,_|
+
+*/
+
+/**
+ * cAPIta server entry
+ * Starts the Express app from app.js on PORT (default 4321).
+ * @module cAPIta/server
+ */
+
+import 'dotenv/config';
+import { createApp } from './app.js';
+
+const PORT = process.env.PORT || 4321;
+
+const app = createApp();
+const server = app.listen(PORT, () => {
+  console.log(`cAPIta listening on port ${PORT}`);
+});
+
+export { app, server };
+export { createApp, CASES } from './app.js';

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@brianfunk/capita",
+  "version": "1.1.0",
+  "description": "cAPIta - Capitalization API powered by capstring. 29 styles, one URL.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "capita": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "app.js",
+    "public"
+  ],
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    }
+  },
+  "scripts": {
+    "start": "node index.js",
+    "demo": "node demo.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint . --format stylish",
+    "lint:report": "eslint . --format html -o coverage/lint-report.html",
+    "dev": "netlify dev"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brianfunk/cAPIta.git"
+  },
+  "keywords": [
+    "capita",
+    "api",
+    "cap",
+    "capitalization",
+    "capitalize",
+    "string",
+    "capstring",
+    "rest",
+    "kebab-case",
+    "camelCase",
+    "snake_case",
+    "title-case",
+    "text-transform",
+    "spell-check"
+  ],
+  "author": "Brian Funk",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/brianfunk/cAPIta/issues"
+  },
+  "homepage": "https://capita-api.netlify.app",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "capstring": "^1.0.0",
+    "dictionary-en": "^4.0.0",
+    "dotenv": "^16.4.0",
+    "express": "^4.21.0",
+    "nspell": "^2.1.0",
+    "serverless-http": "^4.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.17.0",
+    "supertest": "^7.0.0",
+    "vitest": "^4.0.18"
+  }
+}

package/public/index.html

@@ -0,0 +1,315 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>cAPIta</title>
+<meta name="description" content="cAPIta: a tiny REST API that capitalizes strings 29 ways. Type a phrase, get every style, copy the URL.">
+<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect width='100' height='100' rx='18' fill='%23b5d4ff'/><text x='50' y='68' font-size='52' text-anchor='middle' font-family='monospace' font-weight='bold' fill='%231a2a44'>Aa</text></svg>">
+<style>
+  :root {
+    --bg: #fbfcff;
+    --fg: #1a2233;
+    --muted: #5f6b80;
+    --card: #ffffff;
+    --line: #dde4f0;
+    --accent: #b5d4ff;
+    --accent-ink: #1a2a44;
+    --mono: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #0f1420;
+      --fg: #e6ebf5;
+      --muted: #8e9ab3;
+      --card: #171e2e;
+      --line: #2a3448;
+      --accent: #b5d4ff;
+      --accent-ink: #0f1420;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    background: var(--bg);
+    color: var(--fg);
+    font: 16px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif;
+  }
+  main { max-width: 960px; margin: 0 auto; padding: 32px 16px 64px; }
+  pre.logo {
+    font-family: var(--mono);
+    font-size: 13px;
+    line-height: 1.15;
+    margin: 0 0 4px;
+    color: var(--fg);
+    overflow-x: auto;
+  }
+  p.tag { margin: 0 0 24px; color: var(--muted); }
+  p.tag a { color: inherit; }
+  .input {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    background: var(--card);
+    border: 1px solid var(--line);
+    border-radius: 12px;
+    padding: 6px 6px 6px 16px;
+  }
+  .input input {
+    flex: 1;
+    min-width: 0;
+    border: 0;
+    background: transparent;
+    color: var(--fg);
+    font: inherit;
+    font-size: 20px;
+    outline: none;
+  }
+  .input button {
+    border: 0;
+    border-radius: 8px;
+    background: var(--accent);
+    color: var(--accent-ink);
+    font: inherit;
+    font-weight: 600;
+    padding: 8px 14px;
+    cursor: pointer;
+  }
+  .curl {
+    margin: 12px 0 28px;
+    font-family: var(--mono);
+    font-size: 13px;
+    color: var(--muted);
+    word-break: break-all;
+  }
+  .curl a { color: var(--fg); text-decoration: none; border-bottom: 1px dotted var(--muted); }
+  .curl a:hover { border-bottom-style: solid; }
+  h2 {
+    font-size: 13px;
+    letter-spacing: .08em;
+    text-transform: uppercase;
+    color: var(--muted);
+    margin: 28px 0 10px;
+  }
+  .grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+    gap: 10px;
+  }
+  .card {
+    background: var(--card);
+    border: 1px solid var(--line);
+    border-radius: 10px;
+    padding: 10px 12px;
+    cursor: pointer;
+    transition: border-color .15s, transform .15s;
+    min-width: 0;
+  }
+  .card:hover { border-color: var(--accent); }
+  .card:active { transform: scale(.98); }
+  .card.selected { border-color: var(--accent); box-shadow: 0 0 0 2px var(--accent) inset; }
+  .card .style {
+    font-family: var(--mono);
+    font-size: 12px;
+    color: var(--muted);
+    display: flex;
+    justify-content: space-between;
+  }
+  .card .style .hint { opacity: 0; transition: opacity .15s; }
+  .card:hover .style .hint { opacity: 1; }
+  .card .out {
+    font-size: 17px;
+    margin-top: 2px;
+    overflow-wrap: anywhere;
+    min-height: 1.5em;
+  }
+  .card .out:empty::after { content: "\00a0"; }
+  footer {
+    margin-top: 48px;
+    padding-top: 20px;
+    border-top: 1px solid var(--line);
+    color: var(--muted);
+    font-size: 14px;
+  }
+  footer code { font-family: var(--mono); font-size: 13px; color: var(--fg); }
+  footer ul { padding-left: 18px; margin: 8px 0; }
+  footer li { margin: 2px 0; }
+  footer a { color: inherit; }
+  .toast {
+    position: fixed;
+    left: 50%;
+    bottom: 24px;
+    transform: translateX(-50%) translateY(20px);
+    background: var(--fg);
+    color: var(--bg);
+    padding: 8px 14px;
+    border-radius: 8px;
+    font-size: 14px;
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity .2s, transform .2s;
+  }
+  .toast.show { opacity: 1; transform: translateX(-50%) translateY(0); }
+</style>
+</head>
+<body>
+<main>
+  <pre class="logo" aria-label="cAPIta">          _    ____ ___ _
+   ___   / \  |  _ \_ _| |_ __ _
+  / __| / _ \ | |_) | || __/ _` |
+ | (__ / ___ \|  __/| || || (_| |
+  \___/_/   \_\_|  |___|\__\__,_|</pre>
+  <p class="tag">A tiny REST API that capitalizes strings 29 ways. Type something, click a card to copy, or just hit the URL. Powered by <a href="https://github.com/brianfunk/capstring">capstring</a>.</p>
+
+  <div class="input">
+    <input id="text" type="text" value="hello world" placeholder="type a phrase" autocomplete="off" autofocus>
+    <button id="spell" type="button" title="Run the input through the spell checker">spell check</button>
+  </div>
+  <div class="curl" id="curl"></div>
+
+  <div id="groups"></div>
+
+  <footer>
+    <strong>Endpoints</strong>
+    <ul>
+      <li><code>GET /:style/:text</code> or <code>/:style/:text.json|txt|html|xml|yaml|csv|jsonp</code></li>
+      <li><code>GET /chain/:style+:style/:text</code> apply several styles in order</li>
+      <li><code>POST /batch</code> <code>{"inputs":[...],"style":"kebab"}</code> up to 100 strings</li>
+      <li><code>GET /spell/:text</code> spell-corrected text, no API key</li>
+      <li><code>GET /badge/:style/:text</code> SVG badge for your README</li>
+      <li><code>GET /count/:text</code> words and characters, <code>GET /lorem/:n</code> placeholder text</li>
+      <li><code>GET /styles</code> every style name</li>
+    </ul>
+    Self-host with <code>npx @brianfunk/capita</code>. Source on <a href="https://github.com/brianfunk/cAPIta">GitHub</a>. MIT.
+  </footer>
+</main>
+<div class="toast" id="toast">copied</div>
+
+<script>
+(() => {
+  const GROUPS = {
+    'Case': ['upper', 'lower', 'title', 'sentence', 'proper', 'swap', 'same'],
+    'Code': ['camel', 'pascal', 'snake', 'kebab', 'slug', 'constant', 'python', 'dot', 'path', 'train'],
+    'Fun': ['leet', 'reverse', 'sponge', 'mock', 'alternate', 'crazy', 'random', 'hashtag', 'acronym', 'rot13', 'flip', 'none']
+  };
+
+  const input = document.getElementById('text');
+  const groupsEl = document.getElementById('groups');
+  const curlEl = document.getElementById('curl');
+  const toast = document.getElementById('toast');
+  const cards = {};
+  let selected = 'title';
+  let timer = null;
+  let seq = 0;
+
+  const base = location.origin;
+
+  const buildCards = (styles) => {
+    const known = new Set(Object.values(GROUPS).flat());
+    const extra = styles.filter((s) => !known.has(s));
+    const groups = { ...GROUPS };
+    if (extra.length) groups['More'] = extra;
+
+    for (const [name, list] of Object.entries(groups)) {
+      const present = list.filter((s) => styles.includes(s));
+      if (!present.length) continue;
+      const h = document.createElement('h2');
+      h.textContent = `${name} (${present.length})`;
+      groupsEl.appendChild(h);
+      const grid = document.createElement('div');
+      grid.className = 'grid';
+      for (const style of present) {
+        const card = document.createElement('div');
+        card.className = 'card' + (style === selected ? ' selected' : '');
+        card.dataset.style = style;
+        card.innerHTML = `<div class="style"><span>${style}</span><span class="hint">click to copy</span></div><div class="out"></div>`;
+        card.addEventListener('click', () => select(style, true));
+        grid.appendChild(card);
+        cards[style] = card;
+      }
+      groupsEl.appendChild(grid);
+    }
+  };
+
+  const showToast = (msg) => {
+    toast.textContent = msg;
+    toast.classList.add('show');
+    setTimeout(() => toast.classList.remove('show'), 1200);
+  };
+
+  const encode = (s) => encodeURIComponent(s);
+
+  const updateCurl = () => {
+    const text = input.value;
+    const url = `${base}/${selected}/${encode(text)}.json`;
+    curlEl.innerHTML = `curl <a href="${url}" target="_blank" rel="noopener">${url}</a>`;
+  };
+
+  const select = async (style, copy) => {
+    selected = style;
+    for (const [s, c] of Object.entries(cards)) c.classList.toggle('selected', s === style);
+    updateCurl();
+    if (copy) {
+      const out = cards[style].querySelector('.out').textContent;
+      try {
+        await navigator.clipboard.writeText(out);
+        showToast(`copied "${out}"`);
+      } catch {
+        showToast('copy failed');
+      }
+    }
+  };
+
+  const transform = async () => {
+    const text = input.value;
+    const mine = ++seq;
+    updateCurl();
+    if (!text) {
+      for (const c of Object.values(cards)) c.querySelector('.out').textContent = '';
+      return;
+    }
+    const styles = Object.keys(cards);
+    await Promise.all(styles.map(async (style) => {
+      try {
+        const r = await fetch(`${base}/${style}/${encode(text)}.json`);
+        const data = await r.json();
+        if (mine !== seq) return;
+        cards[style].querySelector('.out').textContent = data.output ?? '';
+      } catch {
+        if (mine !== seq) return;
+        cards[style].querySelector('.out').textContent = '';
+      }
+    }));
+  };
+
+  input.addEventListener('input', () => {
+    clearTimeout(timer);
+    timer = setTimeout(transform, 180);
+  });
+
+  document.getElementById('spell').addEventListener('click', async () => {
+    const text = input.value.trim();
+    if (!text) return;
+    try {
+      const r = await fetch(`${base}/spell/${encode(text)}.json`);
+      const data = await r.json();
+      if (data.output && data.output !== text) {
+        input.value = data.output;
+        showToast(`"${text}" → "${data.output}"`);
+        transform();
+      } else {
+        showToast('looks right already');
+      }
+    } catch {
+      showToast('spell check failed');
+    }
+  });
+
+  fetch(`${base}/styles`)
+    .then((r) => r.json())
+    .then((d) => { buildCards(d.styles); transform(); })
+    .catch(() => { buildCards(Object.values(GROUPS).flat()); transform(); });
+})();
+</script>
+</body>
+</html>