stringist 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,137 @@
+# Stringist CLI
+
+Upload Xcode String Catalogs to Stringist from your terminal or CI. Requires Node.js 22 or newer. The npm package includes compiled JavaScript and has no runtime dependencies; Deno is not required.
+
+## Install and configure
+
+After publication:
+
+```sh
+npm install --global stringist
+cd your-app
+stringist init
+```
+
+You can also run `npx stringist init`. The wizard asks for the project (`org/proj`), destination app slug, and source format (`xcstrings`, the default and currently the only supported format). It validates each answer and creates `.stringist/settings.json` in the current directory:
+
+```json
+{
+  "project": "acme/mobile",
+  "app": "ios",
+  "sourceFormat": "xcstrings"
+}
+```
+
+The destination project and app must already exist. Settings contain no credentials and can be committed to your app repository. Running `init` again leaves an existing settings file intact; edit it directly to change the destination. EOF or Ctrl+C cancels setup without saving partial settings. For CI, create the JSON file directly or pipe one answer per line to `init`.
+
+## Upload
+
+Run from the directory containing `.stringist/settings.json`:
+
+```sh
+# Import string keys and definitions, without importing translations.
+stringist upload
+
+# Import French translations as well.
+stringist upload --upload-translations fr
+
+# Select several languages and attach version metadata.
+stringist upload --upload-translations fr --upload-translations pt-BR \
+  --version "1.2.0" --vcs-ref "release/1.2.0"
+```
+
+`upload` recursively finds all `.xcstrings` files under the current directory, including hidden directories. It skips `.git`, `.stringist`, `node_modules`, and symbolic links. All catalogs are sent together in one request, sorted by path. Two catalogs with the same filename cannot be uploaded together because their table namespaces would collide. Missing files, malformed JSON, invalid settings, duplicate table names, and requests exceeding API limits produce a nonzero exit status.
+
+Each upload creates a **complete app version**: the API marks previously active keys missing from this upload as removed, including keys from omitted catalogs. Run from your app root so all its catalogs are included. Language selection does not change this snapshot behavior.
+
+| Option | Behavior |
+| --- | --- |
+| `--upload-translations <lang>` | Import values only for this BCP 47 language tag, e.g. `fr` or `pt-BR`. Repeat to select more languages. Tags are canonicalized and deduplicated. |
+| `--version <name>` | Optional app version name, up to 200 characters. |
+| `--vcs-ref <ref>` | Optional VCS reference, up to 2,000 characters. Defaults to `git rev-parse --verify HEAD`, including from repository subdirectories. Omitted when Git or a commit is unavailable. |
+| `-h`, `--help` | Show usage. |
+
+The default language selection is empty, including the source language. To import source-language values, explicitly select that language too, such as `--upload-translations en`. Unselected localization nodes retain their plural/device/substitution structure but their `stringUnit` text is replaced with empty untranslated placeholders **before transmission**. Existing server translations are preserved; local files are never modified. Comments and catalog metadata are retained. The API archives this filtered catalog, not the unfiltered original.
+
+`stringist --version` (or `stringist -V`) prints the CLI package version. `stringist upload --version <name>` names the app version.
+
+## API and CI
+
+The default origin is `https://api.stringi.st`. Set `STRINGIST_TOKEN` to send an optional bearer token; credentials are read only from the environment and are not written into settings. The current development backend has no authentication requirement.
+
+```sh
+export STRINGIST_TOKEN="your-token"
+stringist upload --version "$RELEASE_VERSION"
+```
+
+For local development, set `STRINGIST_API_URL=http://127.0.0.1:8787`. This variable takes an origin with no path, credentials, query, or fragment. HTTPS is required except on localhost. Redirects are rejected.
+
+The CLI uses a Fetch client generated by `@hey-api/openapi-ts` from the [deployed OpenAPI schema](https://api.stringi.st/openapi.json). The generated operation handles the route, path encoding, request serialization, and response parsing. The CLI configures authentication, timeouts, and user-facing errors. The import request uses slug references:
+
+```text
+POST https://api.stringi.st/v1/projects/acme%2Fmobile/apps/ios/imports/xcstrings
+Content-Type: application/json
+Idempotency-Key: <generated UUID>
+
+{
+  "files": [{ "filename": "Localizable.xcstrings", "content": { ... } }],
+  "languages": [],
+  "name": "1.2.0",
+  "vcsRef": "<commit or explicit reference>"
+}
+```
+
+`name` and `vcsRef` are omitted when unavailable. The deployed API supports qualified project references, app slugs, and empty JSON language selections. UUID references remain supported by the API. Its current public test organization is `test`.
+
+Requests time out after 60 seconds. Errors include the API message and request ID when available. Uploads are not automatically retried; after a connection failure, check the destination's version list before uploading again, since each invocation creates a new version. The API accepts at most 100 catalogs and 20 MiB per request.
+
+## Development and publishing
+
+This package lives at `packages/cli` in the pnpm workspace and is published as `stringist`. Run the following development commands from the repository root.
+
+The OpenAPI snapshot lives in `packages/cli/openapi/stringist.json`; generated files live in `packages/cli/src/generated` and should not be edited manually. Both are committed so building, testing, and publishing do not depend on the deployed API being available.
+
+```sh
+# Regenerate from the committed snapshot.
+pnpm generate:api
+
+# Fetch https://api.stringi.st/openapi.json and regenerate.
+pnpm update:api
+```
+
+Review and commit both the snapshot and generated changes after refreshing. `packages/cli/openapi-ts.config.ts` currently selects the xcstrings import operation; extend its operation filter as CLI commands are added. The deployed document has two unresolved recursive references on the separate translation-update operation. The generator reports these warnings while reading the document; that operation is excluded from this CLI's generated client. The import response's `data` schema is unconstrained, so the CLI still checks the returned version before reporting success.
+
+The generator is pinned to an exact version. TypeScript 5.9 is used because the generator needs the JavaScript compiler API that TypeScript 7 no longer exposes in the same way. The root `pnpm-workspace.yaml` `js-yaml` override keeps the generator's transitive parser on a patched version. These are development dependencies; the published CLI still has no runtime dependencies.
+
+```sh
+pnpm install --frozen-lockfile
+pnpm check
+pnpm test
+pnpm test:package
+
+# Run locally, or install the generated archive to try the npm executable.
+node packages/cli/dist/cli.js --help
+pnpm --filter stringist exec npm pack
+npm install --global ./packages/cli/stringist-0.1.0.tgz
+
+# Publish when ready, using an npm account with access to the package name.
+npm publish ./packages/cli/stringist-0.1.0.tgz
+```
+
+The package uses npm's [`bin`, `files`, and lifecycle script configuration](https://docs.npmjs.com/cli/v11/configuring-npm/package-json/). `prepack` compiles TypeScript and marks the executable; `prepublishOnly` runs type checking and tests. Only `dist` (including the generated client), this README, and npm's package metadata are shipped. `test:package` installs a tarball into a temporary directory and runs the CLI tests against that installation, including the npm command shim. CI installs with the root frozen pnpm lockfile, covers Node 22 and 24 on Linux, macOS, and Windows and checks that generated files match the committed snapshot.
+
+### Manual GitHub Actions release
+
+The **Publish to npm** workflow in `.github/workflows/publish.yml` runs only through `workflow_dispatch`:
+
+1. Open **Actions → Publish to npm → Run workflow** and choose the branch or tag containing the release code. The workflow must be present on the repository's default branch to appear in Actions.
+2. Enter an exact version such as `0.1.0` or `0.2.0-beta.1` and an npm dist-tag (`latest` for stable releases; `next` or `beta` for prereleases).
+3. The workflow verifies generated code, sets the requested version only in `packages/cli/package.json` in its temporary checkout, checks types, runs tests, validates an installed tarball, saves a package artifact, and publishes the release tarball to npm. It sets package repository metadata from the GitHub repository running the job, including `repository.directory: "packages/cli"`, and does not push version commits or Git tags. Update the repository's version separately when desired.
+
+Configure [npm trusted publishing](https://docs.npmjs.com/trusted-publishers/) for the `stringist` package with your GitHub owner, repository, and workflow filename **`publish.yml`**, and permit the `npm publish` action. The workflow grants `id-token: write` and uses a GitHub-hosted runner; no npm token is needed for configured trusted publishing. There is no GitHub environment name to enter. npm automatically attaches provenance when its requirements are met.
+
+The GitHub repository can remain private while the CLI is public on npm: the package and workflow both specify public access. npm trusted publishing supports private repositories, but does not generate provenance for them. The workflow publishes an explicitly local `./release/…tgz` path; omitting `./` can make npm interpret it as a GitHub repository shorthand.
+
+For a first publication before trusted publishing is configured, an optional repository secret **`NPM_TOKEN`** can supply a granular npm token with publish permission for `stringist` and bypass 2FA enabled. Remove that secret after configuring trusted publishing to switch to OIDC. The npm account must own or have publish access to the package name. A version already present on npm cannot be published again; choose a new version when rerunning after a successful release.
+
+The package currently declares `UNLICENSED` (no license grant). Set the intended license before distributing it under an open-source license. No registry publication is performed by the build or tests.

package/dist/api.js

@@ -0,0 +1,44 @@
+import { randomUUID } from 'node:crypto';
+import { createClient } from './generated/client/index.js';
+import { postV1ProjectsByProjectIdAppsByAppIdImportsXcstrings } from './generated/sdk.gen.js';
+export const API_ORIGIN = 'https://api.stringi.st';
+export class Api {
+    client;
+    constructor(origin = API_ORIGIN, token) {
+        const url = new URL(origin);
+        if (url.username || url.password || url.search || url.hash || url.pathname !== '/') {
+            throw new Error('STRINGIST_API_URL must be an origin without credentials, a path, query, or fragment.');
+        }
+        if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))) {
+            throw new Error('STRINGIST_API_URL must use HTTPS (HTTP is allowed for localhost).');
+        }
+        this.client = createClient({
+            baseUrl: url.origin,
+            headers: { Accept: 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+            redirect: 'error',
+            parseAs: 'json',
+        });
+    }
+    async importCatalogs(settings, body) {
+        const { data, error, response } = await postV1ProjectsByProjectIdAppsByAppIdImportsXcstrings({
+            client: this.client,
+            path: { projectId: settings.project, appId: settings.app },
+            body,
+            headers: { 'Idempotency-Key': randomUUID() },
+            signal: AbortSignal.timeout(60_000),
+            throwOnError: false,
+        });
+        if (!response) {
+            throw new Error(`API request failed: ${error instanceof Error ? error.message : 'connection failed'}. The upload outcome may be unknown; check the app’s versions before uploading again.`);
+        }
+        if (typeof error === 'string' || error instanceof SyntaxError)
+            throw new Error(`API returned HTTP ${response.status} with a non-JSON response.`);
+        if (!response.ok) {
+            const requestId = error?.error?.requestId ?? response.headers.get('x-request-id');
+            throw new Error(`API returned HTTP ${response.status}: ${error?.error?.message ?? response.statusText}${requestId ? ` (request ${requestId})` : ''}`);
+        }
+        if (!data || typeof data !== 'object' || !('data' in data))
+            throw new Error('API returned an invalid response: missing data.');
+        return data.data;
+    }
+}

package/dist/catalogs.js

@@ -0,0 +1,115 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+export const MAX_BYTES = 20 * 1024 * 1024;
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function locale(value) {
+    try {
+        if (value.length > 100)
+            throw new Error();
+        const result = Intl.getCanonicalLocales(value);
+        if (result.length !== 1)
+            throw new Error();
+        return result[0];
+    }
+    catch {
+        throw new Error(`Invalid language ${JSON.stringify(value)}. Use a BCP 47 tag such as fr or pt-BR.`);
+    }
+}
+// Preserve plural/device/substitution definitions without sending unselected text.
+function clearText(node, path, depth = 0) {
+    if (depth > 64 || !object(node))
+        throw new Error(`Invalid localization structure in ${path}.`);
+    if (node.stringUnit !== undefined) {
+        if (!object(node.stringUnit))
+            throw new Error(`Invalid stringUnit in ${path}.`);
+        node.stringUnit.value = '';
+        node.stringUnit.state = 'new';
+    }
+    if (node.variations !== undefined) {
+        if (!object(node.variations))
+            throw new Error(`Invalid variations in ${path}.`);
+        for (const cases of Object.values(node.variations)) {
+            if (!object(cases))
+                throw new Error(`Invalid variation cases in ${path}.`);
+            for (const child of Object.values(cases))
+                clearText(child, path, depth + 1);
+        }
+    }
+    if (node.substitutions !== undefined) {
+        if (!object(node.substitutions))
+            throw new Error(`Invalid substitutions in ${path}.`);
+        for (const child of Object.values(node.substitutions))
+            clearText(child, path, depth + 1);
+    }
+}
+export async function collectCatalogs(cwd, languages) {
+    const paths = [];
+    async function walk(directory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        for (const entry of entries) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!['.git', '.stringist', 'node_modules'].includes(entry.name))
+                    await walk(path);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.xcstrings')) {
+                paths.push(path);
+                if (paths.length > 100)
+                    throw new Error('The import API accepts at most 100 catalogs per upload.');
+            }
+        }
+    }
+    await walk(cwd);
+    if (!paths.length)
+        throw new Error(`No .xcstrings files found under ${cwd}.`);
+    const names = new Map();
+    const selected = new Set(languages);
+    const files = [];
+    let totalBytes = 0;
+    for (const path of paths) {
+        const filename = basename(path);
+        const namespace = filename.slice(0, -10);
+        if (!namespace || namespace.length > 200)
+            throw new Error(`Invalid catalog table name: ${relative(cwd, path)}.`);
+        const previous = names.get(namespace);
+        if (previous)
+            throw new Error(`Duplicate catalog table ${namespace}: ${relative(cwd, previous)} and ${relative(cwd, path)}. The API requires unique filenames.`);
+        names.set(namespace, path);
+        totalBytes += (await stat(path)).size;
+        if (totalBytes > MAX_BYTES)
+            throw new Error('Catalogs exceed the API’s 20 MiB upload limit.');
+        let content;
+        try {
+            content = JSON.parse((await readFile(path, 'utf8')).replace(/^\uFEFF/, ''));
+        }
+        catch (error) {
+            throw new Error(`Cannot read catalog ${relative(cwd, path)}: ${error.message}`);
+        }
+        if (!object(content) || typeof content.sourceLanguage !== 'string' || typeof content.version !== 'string' || !content.version || !object(content.strings)) {
+            throw new Error(`Invalid xcstrings catalog ${relative(cwd, path)}: expected sourceLanguage, version, and strings.`);
+        }
+        locale(content.sourceLanguage);
+        for (const [key, entry] of Object.entries(content.strings)) {
+            if (!object(entry))
+                throw new Error(`Invalid string entry ${JSON.stringify(key)} in ${filename}.`);
+            if (entry.localizations === undefined)
+                continue;
+            if (!object(entry.localizations))
+                throw new Error(`Invalid localizations in ${filename}.`);
+            const seen = new Set();
+            for (const [language, node] of Object.entries(entry.localizations)) {
+                const canonical = locale(language);
+                if (seen.has(canonical))
+                    throw new Error(`Colliding language tags for ${canonical} in ${filename}.`);
+                seen.add(canonical);
+                if (!selected.has(canonical))
+                    clearText(node, filename);
+            }
+        }
+        files.push({ filename, content });
+    }
+    return files;
+}

package/dist/cli.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import { readFile, lstat } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { parseArgs } from 'node:util';
+import { Api, API_ORIGIN } from './api.js';
+import { locale } from './catalogs.js';
+import { project, settingsPath, slug, sourceFormat, writeSettings } from './settings.js';
+import { upload } from './upload.js';
+const help = `Usage: stringist <command> [options]
+
+Commands:
+  init                         Create .stringist/settings.json interactively
+  upload                       Upload all catalogs below the current directory
+
+Upload options:
+  --upload-translations <lang>  Import translations for a language; repeat for more
+  --version <name>             Name the imported app version
+  --vcs-ref <ref>              VCS reference (defaults to the current Git commit)
+
+General options:
+  -h, --help                   Show help
+  -V, --version                Show CLI version (outside the upload command)
+
+Environment:
+  STRINGIST_TOKEN              Optional API bearer token
+  STRINGIST_API_URL            API origin (default: https://api.stringi.st)
+
+Uploads import keys only unless --upload-translations is supplied.
+Examples:
+  stringist init
+  stringist upload
+  stringist upload --upload-translations fr --version 1.2.0
+`;
+async function init(cwd) {
+    try {
+        await lstat(settingsPath(cwd));
+        throw new Error(`${settingsPath(cwd)} already exists. Edit it to change the destination.`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const lines = createInterface({ input: process.stdin, output: process.stdout, terminal: Boolean(process.stdin.isTTY) });
+    const iterator = lines[Symbol.asyncIterator]();
+    let interrupted = false;
+    const interrupt = () => { interrupted = true; lines.close(); };
+    lines.on('SIGINT', interrupt);
+    process.once('SIGINT', interrupt);
+    async function ask(label, validate, fallback) {
+        while (true) {
+            process.stdout.write(`${label}${fallback ? ` [${fallback}]` : ''}: `);
+            const next = await iterator.next();
+            if (next.done || interrupted)
+                throw new Error('Initialization cancelled; settings were not written.');
+            try {
+                return validate(next.value.trim() || fallback || '');
+            }
+            catch (error) {
+                console.error(error.message);
+            }
+        }
+    }
+    try {
+        const settings = {
+            project: await ask('Project (org/proj)', project),
+            app: await ask('Destination app slug', (value) => slug(value, 'App')),
+            sourceFormat: await ask('Source format', sourceFormat, 'xcstrings'),
+        };
+        await writeSettings(cwd, settings);
+        console.log(`Created ${settingsPath(cwd)}. Run stringist upload to upload your catalogs.`);
+    }
+    finally {
+        lines.close();
+        process.removeListener('SIGINT', interrupt);
+        if (interrupted)
+            process.exitCode = 130;
+    }
+}
+function textOption(value, label, max) {
+    if (value !== undefined && (!value.trim() || value.length > max))
+        throw new Error(`${label} must contain 1–${max} characters.`);
+    return value;
+}
+async function main(args) {
+    const command = args[0];
+    if (!command || command === '--help' || command === '-h') {
+        console.log(help);
+        return;
+    }
+    if (command === '--version' || command === '-V') {
+        if (args.length !== 1)
+            throw new Error('The CLI version flag does not take arguments.');
+        console.log(JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version);
+        return;
+    }
+    if (command !== 'init' && command !== 'upload')
+        throw new Error(`Unknown command ${command}. Run stringist --help.`);
+    const { values, tokens } = parseArgs({
+        args: args.slice(1), strict: true, allowPositionals: false, tokens: true,
+        options: {
+            help: { type: 'boolean', short: 'h' },
+            ...(command === 'upload' ? {
+                'upload-translations': { type: 'string', multiple: true },
+                version: { type: 'string' },
+                'vcs-ref': { type: 'string' },
+            } : {}),
+        },
+    });
+    if (values.help) {
+        console.log(help);
+        return;
+    }
+    for (const name of ['version', 'vcs-ref']) {
+        if (tokens.filter((token) => token.kind === 'option' && token.name === name).length > 1)
+            throw new Error(`--${name} may only be provided once.`);
+    }
+    if (command === 'init') {
+        await init(process.cwd());
+        return;
+    }
+    const languages = [...new Set((values['upload-translations'] ?? []).map(locale))];
+    if (languages.length > 200)
+        throw new Error('At most 200 languages may be selected.');
+    await upload(process.cwd(), {
+        languages,
+        version: textOption(values.version, '--version', 200),
+        vcsRef: textOption(values['vcs-ref'], '--vcs-ref', 2000),
+    }, new Api(process.env.STRINGIST_API_URL || API_ORIGIN, process.env.STRINGIST_TOKEN), console.log);
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(`stringist: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode ||= 1;
+});

package/dist/generated/client/client.gen.js

@@ -0,0 +1,216 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.gen.js';
+import { getValidRequestBody } from '../core/utils.gen.js';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen.js';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams(opts);
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const resolvedOpts = opts;
+        const url = buildUrl(resolvedOpts);
+        return { opts: resolvedOpts, url };
+    };
+    const request = async (options) => {
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
+        let response;
+        try {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts),
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns) {
+                if (fn) {
+                    request = await fn(request, opts);
+                }
+            }
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns) {
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
+            }
+            const result = {
+                request,
+                response,
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto'
+                    ? getParseAs(response.headers.get('Content-Type'))
+                    : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch (parseAs) {
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data'
+                        ? emptyData
+                        : {
+                            data: emptyData,
+                            ...result,
+                        };
+                }
+                let data;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'formData':
+                    case 'text':
+                        data = await response[parseAs]();
+                        break;
+                    case 'json': {
+                        // Some servers return 200 with no Content-Length and empty body.
+                        // response.json() would throw; read as text and parse if non-empty.
+                        const text = await response.text();
+                        data = text ? JSON.parse(text) : {};
+                        break;
+                    }
+                    case 'stream':
+                        return opts.responseStyle === 'data'
+                            ? response.body
+                            : {
+                                data: response.body,
+                                ...result,
+                            };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
+                }
+                return opts.responseStyle === 'data'
+                    ? data
+                    : {
+                        data,
+                        ...result,
+                    };
+            }
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
+            }
+            catch {
+                // noop
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
+                }
+            }
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response,
+                };
+        }
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+    return {
+        buildUrl: _buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};

package/dist/generated/client/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen.js';
+export { buildClientParams } from '../core/params.gen.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
+export { createClient } from './client.gen.js';
+export { createConfig, mergeHeaders } from './utils.gen.js';

package/dist/generated/client/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};