@dichovsky/testrail-api-client 1.0.0 → 2.1.0

package/dist/cli/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { TestRailClient } from '../client.js';
+import { resolveAuth } from './auth.js';
+import { createOutput } from './output.js';
+import { dispatch } from './dispatch.js';
+import { runInstallSkill } from './install-skill.js';
+// ── Version ───────────────────────────────────────────────────────────────────
+const require = createRequire(import.meta.url);
+const VERSION = require('../../package.json').version;
+// ── Help ──────────────────────────────────────────────────────────────────────
+const HELP = `
+testrail <resource> <action> [args] [options]
+
+Read actions:
+  project  get <id> | list [--limit N] [--offset N]
+  suite    get <id> | list --project-id <id>
+  case     get <id> | list --project-id <id> [--suite-id <id>]
+  run      get <id> | list --project-id <id> [--limit N] [--offset N]
+  result   list --run-id <id> [--limit N] [--offset N]
+  milestone  get <id> | list --project-id <id> [--limit N] [--offset N]
+  user     get <id> | list [--limit N] [--offset N]
+
+Write actions (body via --data | --data-file | stdin):
+  case   add <section_id>           --data '{"title":"..."}'
+  case   update <case_id>           --data '{"title":"..."}'
+  run    add <project_id>           --data '{"name":"..."}'
+  run    close <run_id>             (no body)
+  result add <run_id> <case_id>     --data '{"status_id":1}'
+  result add-bulk <run_id>          --data '{"results":[{"case_id":1,"status_id":1}]}'
+
+Meta:
+  install-skill [--global] [--force] [--print-path]
+                                    Install the testrail-cli skill to
+                                    ./.claude/skills/testrail-cli (default)
+                                    or ~/.claude/skills/testrail-cli (--global)
+
+Auth (env var or flag):
+  TESTRAIL_BASE_URL / --base-url <url>
+  TESTRAIL_EMAIL    / --email <email>
+  TESTRAIL_API_KEY  / --api-key <key>
+
+Options:
+  --data <json>         Inline JSON body for write actions
+  --data-file <path>    Read JSON body from file
+  --dry-run             Validate payload but don't call the API
+  --format json|table   Output format (default: json)
+  --quiet               Suppress output; use exit code 0/1
+  --global              install-skill: install to ~/.claude/skills/ (default: ./.claude/skills/)
+  --force               install-skill: overwrite an existing SKILL.md
+  --print-path          install-skill: print bundled SKILL.md path and exit
+  --help                Show this help
+  --version             Print version
+
+For body-bearing write actions (all except 'run close'), exactly one body source
+is required (--data | --data-file | stdin). Stdin is auto-detected when input
+is piped (process.stdin.isTTY === false).
+`.trim();
+// ── Entry Point ───────────────────────────────────────────────────────────────
+/**
+ * Compute exit code in an async function and apply `process.exit()` once
+ * at the very end. parseArgs and createOutput are invoked inside main() so
+ * any failure during initialization (e.g. an invalid CLI shape that makes
+ * parseArgs throw) is funneled through the same exit-code return path
+ * rather than escaping as an uncaught module-evaluation error.
+ */
+async function main() {
+    let values;
+    let positionals;
+    try {
+        const parsed = parseArgs({
+            args: process.argv.slice(2),
+            options: {
+                'base-url': { type: 'string' },
+                email: { type: 'string' },
+                'api-key': { type: 'string' },
+                format: { type: 'string', default: 'json' },
+                quiet: { type: 'boolean', default: false },
+                help: { type: 'boolean', default: false },
+                version: { type: 'boolean', default: false },
+                'project-id': { type: 'string' },
+                'suite-id': { type: 'string' },
+                'run-id': { type: 'string' },
+                'case-id': { type: 'string' },
+                limit: { type: 'string' },
+                offset: { type: 'string' },
+                data: { type: 'string' },
+                'data-file': { type: 'string' },
+                'dry-run': { type: 'boolean', default: false },
+                global: { type: 'boolean', default: false },
+                force: { type: 'boolean', default: false },
+                'print-path': { type: 'boolean', default: false },
+            },
+            allowPositionals: true,
+            strict: false,
+        });
+        values = parsed.values;
+        positionals = parsed.positionals;
+        /* v8 ignore start -- defensive: parseArgs with strict:false is highly
+           tolerant; this catch funnels any future-Node-version edge cases
+           through the controlled exit path rather than crashing the module. */
+    }
+    catch (e) {
+        process.stderr.write(`Error: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    /* v8 ignore stop */
+    const quiet = values['quiet'] === true;
+    const formatRaw = values['format'];
+    const format = formatRaw === 'table' ? 'table' : 'json';
+    const { out, err } = createOutput({ quiet, format });
+    if (values['version'] === true) {
+        process.stdout.write(`testrail-cli v${VERSION}\n`);
+        return 0;
+    }
+    if (values['help'] === true || positionals.length === 0) {
+        process.stdout.write(`${HELP}\n`);
+        return 0;
+    }
+    // `install-skill` is a meta-command (manages the bundled skill on the
+    // user's filesystem). It deliberately sits outside the normal
+    // resource:action dispatch since there is no API call involved.
+    if (positionals[0] === 'install-skill') {
+        return runInstallSkill({
+            global: values['global'] === true,
+            force: values['force'] === true,
+            printPath: values['print-path'] === true,
+            quiet,
+        }, import.meta.url);
+    }
+    const [resource, action, ...rest] = positionals;
+    const pathParams = rest;
+    if (resource === undefined || resource === '' || action === undefined || action === '') {
+        process.stderr.write('Usage: testrail <resource> <action> [args] [options]\nRun with --help for details.\n');
+        return 1;
+    }
+    const dispatched = dispatch(resource, action);
+    if (!dispatched.ok) {
+        err(dispatched.error);
+        return 1;
+    }
+    const auth = resolveAuth({
+        baseUrl: values['base-url'],
+        email: values['email'],
+        apiKey: values['api-key'],
+    }, {
+        ...(process.env['TESTRAIL_BASE_URL'] !== undefined && {
+            TESTRAIL_BASE_URL: process.env['TESTRAIL_BASE_URL'],
+        }),
+        ...(process.env['TESTRAIL_EMAIL'] !== undefined && { TESTRAIL_EMAIL: process.env['TESTRAIL_EMAIL'] }),
+        ...(process.env['TESTRAIL_API_KEY'] !== undefined && { TESTRAIL_API_KEY: process.env['TESTRAIL_API_KEY'] }),
+    });
+    if (!auth.ok) {
+        err(auth.error);
+        return 1;
+    }
+    const args = {
+        pathParams,
+        ...(values['project-id'] !== undefined && { projectId: values['project-id'] }),
+        ...(values['suite-id'] !== undefined && { suiteId: values['suite-id'] }),
+        ...(values['run-id'] !== undefined && { runId: values['run-id'] }),
+        ...(values['case-id'] !== undefined && { caseId: values['case-id'] }),
+        ...(values['limit'] !== undefined && { limit: values['limit'] }),
+        ...(values['offset'] !== undefined && { offset: values['offset'] }),
+    };
+    const bodyInput = {
+        ...(values['data'] !== undefined && { dataFlag: values['data'] }),
+        ...(values['data-file'] !== undefined && { dataFileFlag: values['data-file'] }),
+        // Pass a thunk (not the read contents) so resolveBody() only drains
+        // stdin when it actually selects stdin as the body source. Read
+        // actions, no-body writes (`run close`), and write actions that
+        // received --data or --data-file never invoke this.
+        ...(process.stdin.isTTY === false && { readStdin: () => readFileSync(0, 'utf-8') }),
+    };
+    const dryRun = values['dry-run'] === true;
+    let client;
+    try {
+        client = new TestRailClient(auth.config);
+        await dispatched.handler({ client, args, bodyInput, dryRun, out });
+        return 0;
+    }
+    catch (e) {
+        err(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    finally {
+        client?.destroy();
+    }
+}
+/* v8 ignore start -- defensive: main() catches all reachable errors internally; this handler exists only for hypothetical failures (e.g., broken-pipe in process.stdout.write) that bypass the inner try/catch. */
+main().then((code) => process.exit(code), (e) => {
+    process.stderr.write(`Error: ${e instanceof Error ? e.message : String(e)}\n`);
+    process.exit(1);
+});
+/* v8 ignore stop */
+//# sourceMappingURL=index.js.map

package/dist/cli/install-skill.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `testrail install-skill` — copy the bundled SKILL.md from this package's
+ * own `skill/` directory into a Claude Code skills folder so the agent can
+ * auto-load it.
+ *
+ * Defaults: project-scoped install (`./.claude/skills/testrail-cli/`).
+ * Pass `--global` for `~/.claude/skills/testrail-cli/`. Pass `--force` to
+ * overwrite an existing file. Pass `--print-path` to print the bundled
+ * source path without installing (useful for vendoring / scripting).
+ *
+ * This is a meta-command — it operates on the user's filesystem, not on
+ * TestRail — so it sits outside the normal `resource:action` dispatch.
+ * Invoked directly from `index.ts` when positionals[0] === 'install-skill'.
+ */
+export interface InstallSkillOptions {
+    global: boolean;
+    force: boolean;
+    printPath: boolean;
+    quiet: boolean;
+    /** Override for tests; resolved from import.meta.url otherwise. */
+    sourceOverride?: string;
+    /** Override target root for tests; otherwise `homedir()` or `process.cwd()`. */
+    cwdOverride?: string;
+    homeOverride?: string;
+}
+/**
+ * Resolves the bundled `skill/SKILL.md` path. At runtime, the compiled
+ * handler lives at `<packageRoot>/dist/cli/install-skill.js`; the bundled
+ * skill ships in `<packageRoot>/skill/SKILL.md`. Two `..` segments climb
+ * from `dist/cli/` (the handler's dirname) to the package root, then
+ * `skill/SKILL.md` reaches the bundled file.
+ */
+export declare function getBundledSkillPath(metaUrl: string): string;
+export declare function runInstallSkill(opts: InstallSkillOptions, metaUrl: string): number;
+//# sourceMappingURL=install-skill.d.ts.map

package/dist/cli/install-skill.js

@@ -0,0 +1,71 @@
+/**
+ * `testrail install-skill` — copy the bundled SKILL.md from this package's
+ * own `skill/` directory into a Claude Code skills folder so the agent can
+ * auto-load it.
+ *
+ * Defaults: project-scoped install (`./.claude/skills/testrail-cli/`).
+ * Pass `--global` for `~/.claude/skills/testrail-cli/`. Pass `--force` to
+ * overwrite an existing file. Pass `--print-path` to print the bundled
+ * source path without installing (useful for vendoring / scripting).
+ *
+ * This is a meta-command — it operates on the user's filesystem, not on
+ * TestRail — so it sits outside the normal `resource:action` dispatch.
+ * Invoked directly from `index.ts` when positionals[0] === 'install-skill'.
+ */
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolves the bundled `skill/SKILL.md` path. At runtime, the compiled
+ * handler lives at `<packageRoot>/dist/cli/install-skill.js`; the bundled
+ * skill ships in `<packageRoot>/skill/SKILL.md`. Two `..` segments climb
+ * from `dist/cli/` (the handler's dirname) to the package root, then
+ * `skill/SKILL.md` reaches the bundled file.
+ */
+export function getBundledSkillPath(metaUrl) {
+    return resolve(dirname(fileURLToPath(metaUrl)), '..', '..', 'skill', 'SKILL.md');
+}
+export function runInstallSkill(opts, metaUrl) {
+    // Match the rest of the CLI's --quiet semantics (createOutput in
+    // output.ts): when quiet, suppress both stdout success messages AND
+    // stderr errors. Callers rely on exit code 0/1 only.
+    const writeErr = (message) => {
+        if (!opts.quiet)
+            process.stderr.write(`Error: ${message}\n`);
+    };
+    const source = opts.sourceOverride ?? getBundledSkillPath(metaUrl);
+    if (opts.printPath) {
+        if (!opts.quiet)
+            process.stdout.write(`${source}\n`);
+        return 0;
+    }
+    if (!existsSync(source)) {
+        writeErr(`bundled SKILL.md not found at ${source}`);
+        return 1;
+    }
+    const targetRoot = opts.global ? (opts.homeOverride ?? homedir()) : (opts.cwdOverride ?? process.cwd());
+    const target = join(targetRoot, '.claude', 'skills', 'testrail-cli', 'SKILL.md');
+    if (existsSync(target) && !opts.force) {
+        writeErr(`SKILL.md already exists at ${target}. Re-run with --force to overwrite.`);
+        return 1;
+    }
+    try {
+        mkdirSync(dirname(target), { recursive: true });
+        copyFileSync(source, target);
+        /* v8 ignore start -- defensive: triggered only by filesystem failures
+           (permission denied, full disk, etc.) that are flaky to simulate in
+           CI. The error path is exercised manually if invoked under an
+           unwritable HOME. */
+    }
+    catch (e) {
+        writeErr(`failed to install skill: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+    /* v8 ignore stop */
+    if (!opts.quiet) {
+        process.stdout.write(`Installed testrail-cli skill → ${target}\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=install-skill.js.map

package/dist/cli/metadata.d.ts

@@ -0,0 +1,37 @@
+import type { z } from 'zod';
+/**
+ * Declarative spec for every resource:action exposed by the CLI.
+ *
+ * Single source of truth shared by:
+ * - PR 3 tests: assert both directions of the metadata↔dispatch
+ *   correspondence — every `ACTIONS` entry must have a registered handler
+ *   in `dispatch.ts` HANDLERS, and every HANDLERS key must have an
+ *   `ACTIONS` entry. Catches drift in either direction.
+ * - PR 4 skill generator: renders the `<!-- GENERATED:command-table -->` and
+ *   `<!-- GENERATED:payload-schemas -->` regions of `skill/SKILL.md` from
+ *   this array.
+ *
+ * Adding a new action requires touching exactly two places: the handler in
+ * `src/cli/handlers/`, and an entry here. The dispatcher and the skill stay
+ * accurate automatically.
+ */
+export interface PathParam {
+    name: string;
+    description: string;
+}
+export interface ActionSpec {
+    resource: string;
+    action: string;
+    summary: string;
+    pathParams: readonly PathParam[];
+    /** Zod schema for the request body. `undefined` for read actions and for
+     *  no-body POSTs like `run close`. */
+    bodySchema?: z.ZodTypeAny;
+    /** True for write actions (POST / payload-bearing). Affects skill recipes,
+     *  generator output, and `--dry-run` applicability. */
+    isWrite: boolean;
+}
+export declare const ACTIONS: readonly ActionSpec[];
+/** Look up the spec for a resource:action pair, or return undefined. */
+export declare function getActionSpec(resource: string, action: string): ActionSpec | undefined;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/cli/metadata.js

@@ -0,0 +1,151 @@
+import { AddCasePayloadSchema, UpdateCasePayloadSchema, AddRunPayloadSchema, AddResultPayloadSchema, AddResultsForCasesPayloadSchema, } from '../schemas.js';
+export const ACTIONS = [
+    // ── Read actions ──────────────────────────────────────────────────────
+    {
+        resource: 'project',
+        action: 'get',
+        summary: 'Fetch a single project by ID',
+        pathParams: [{ name: 'project_id', description: 'TestRail project ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'project',
+        action: 'list',
+        summary: 'List all projects (paginated)',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'suite',
+        action: 'get',
+        summary: 'Fetch a single suite by ID',
+        pathParams: [{ name: 'suite_id', description: 'TestRail suite ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'suite',
+        action: 'list',
+        summary: 'List suites in a project',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'case',
+        action: 'get',
+        summary: 'Fetch a single test case by ID',
+        pathParams: [{ name: 'case_id', description: 'TestRail case ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'case',
+        action: 'list',
+        summary: 'List cases in a project (optionally filtered by suite)',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'run',
+        action: 'get',
+        summary: 'Fetch a single run by ID',
+        pathParams: [{ name: 'run_id', description: 'TestRail run ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'run',
+        action: 'list',
+        summary: 'List runs in a project (paginated)',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'result',
+        action: 'list',
+        summary: 'List results for a run (paginated)',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'milestone',
+        action: 'get',
+        summary: 'Fetch a single milestone by ID',
+        pathParams: [{ name: 'milestone_id', description: 'TestRail milestone ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'milestone',
+        action: 'list',
+        summary: 'List milestones in a project (paginated)',
+        pathParams: [],
+        isWrite: false,
+    },
+    {
+        resource: 'user',
+        action: 'get',
+        summary: 'Fetch a single user by ID',
+        pathParams: [{ name: 'user_id', description: 'TestRail user ID' }],
+        isWrite: false,
+    },
+    {
+        resource: 'user',
+        action: 'list',
+        summary: 'List users (paginated)',
+        pathParams: [],
+        isWrite: false,
+    },
+    // ── Write actions ─────────────────────────────────────────────────────
+    {
+        resource: 'case',
+        action: 'add',
+        summary: 'Create a new test case under a section',
+        pathParams: [{ name: 'section_id', description: 'Section to create the case under' }],
+        bodySchema: AddCasePayloadSchema,
+        isWrite: true,
+    },
+    {
+        resource: 'case',
+        action: 'update',
+        summary: 'Update an existing test case (partial fields)',
+        pathParams: [{ name: 'case_id', description: 'TestRail case ID' }],
+        bodySchema: UpdateCasePayloadSchema,
+        isWrite: true,
+    },
+    {
+        resource: 'run',
+        action: 'add',
+        summary: 'Create a new test run in a project',
+        pathParams: [{ name: 'project_id', description: 'TestRail project ID' }],
+        bodySchema: AddRunPayloadSchema,
+        isWrite: true,
+    },
+    {
+        resource: 'run',
+        action: 'close',
+        summary: 'Close a test run (no body)',
+        pathParams: [{ name: 'run_id', description: 'TestRail run ID' }],
+        isWrite: true,
+    },
+    {
+        resource: 'result',
+        action: 'add',
+        summary: 'Record a single result for a case in a run',
+        pathParams: [
+            { name: 'run_id', description: 'TestRail run ID' },
+            { name: 'case_id', description: 'TestRail case ID' },
+        ],
+        bodySchema: AddResultPayloadSchema,
+        isWrite: true,
+    },
+    {
+        resource: 'result',
+        action: 'add-bulk',
+        summary: 'Record multiple results for cases in one API call',
+        pathParams: [{ name: 'run_id', description: 'TestRail run ID' }],
+        bodySchema: AddResultsForCasesPayloadSchema,
+        isWrite: true,
+    },
+];
+/** Look up the spec for a resource:action pair, or return undefined. */
+export function getActionSpec(resource, action) {
+    return ACTIONS.find((a) => a.resource === resource && a.action === action);
+}
+//# sourceMappingURL=metadata.js.map

package/dist/cli/output.d.ts

@@ -0,0 +1,28 @@
+export interface OutputOptions {
+    quiet: boolean;
+    format: 'json' | 'table';
+}
+export interface Output {
+    out: (data: unknown) => void;
+    err: (message: string) => void;
+}
+export declare function valueToString(v: unknown): string;
+export declare function renderTable(data: unknown): string;
+/**
+ * Best-effort JSON.stringify with two fallbacks, guaranteeing the return
+ * value is always parseable JSON for downstream tools (e.g., `jq`):
+ *
+ * 1. If serialization throws (circular reference, nested BigInt, etc.),
+ *    emit a structured `{ error, message }` JSON object.
+ * 2. If `JSON.stringify` returns the JS value `undefined` — which it does
+ *    for `undefined`, function, or symbol inputs — emit the JSON literal
+ *    `"null"`. Without this guard, the caller's template literal would
+ *    coerce that `undefined` to the string `"undefined"`, which is not
+ *    valid JSON.
+ *
+ * Exported so unit tests can verify the fallbacks without spawning a
+ * subprocess.
+ */
+export declare function safeJsonStringify(data: unknown): string;
+export declare function createOutput(opts: OutputOptions): Output;
+//# sourceMappingURL=output.d.ts.map

package/dist/cli/output.js

@@ -0,0 +1,84 @@
+export function valueToString(v) {
+    if (v === null || v === undefined)
+        return '';
+    if (typeof v === 'object') {
+        try {
+            return JSON.stringify(v);
+        }
+        catch {
+            // JSON.stringify throws on circular refs and nested BigInt.
+            return '[Object]';
+        }
+    }
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'number' || typeof v === 'boolean' || typeof v === 'bigint')
+        return String(v);
+    if (typeof v === 'symbol')
+        return v.toString();
+    return '[Function]';
+}
+function getField(row, key) {
+    if (typeof row !== 'object' || row === null)
+        return undefined;
+    return row[key];
+}
+export function renderTable(data) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (rows.length === 0)
+        return '(empty)';
+    const first = rows[0];
+    if (typeof first !== 'object' || first === null) {
+        return rows.map(String).join('\n');
+    }
+    const keys = Object.keys(first);
+    const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => valueToString(getField(r, k)).length)));
+    const line = widths.map((w) => '-'.repeat(w)).join('-+-');
+    const header = keys.map((k, i) => k.padEnd(widths[i] ?? k.length)).join(' | ');
+    const body = rows.map((r) => keys.map((k, i) => valueToString(getField(r, k)).padEnd(widths[i] ?? k.length)).join(' | '));
+    return [header, line, ...body].join('\n');
+}
+/**
+ * Best-effort JSON.stringify with two fallbacks, guaranteeing the return
+ * value is always parseable JSON for downstream tools (e.g., `jq`):
+ *
+ * 1. If serialization throws (circular reference, nested BigInt, etc.),
+ *    emit a structured `{ error, message }` JSON object.
+ * 2. If `JSON.stringify` returns the JS value `undefined` — which it does
+ *    for `undefined`, function, or symbol inputs — emit the JSON literal
+ *    `"null"`. Without this guard, the caller's template literal would
+ *    coerce that `undefined` to the string `"undefined"`, which is not
+ *    valid JSON.
+ *
+ * Exported so unit tests can verify the fallbacks without spawning a
+ * subprocess.
+ */
+export function safeJsonStringify(data) {
+    try {
+        // JSON.stringify returns the JS value undefined for inputs without a
+        // JSON representation (undefined, function, symbol); fall back to the
+        // JSON literal "null" so the result is always a parseable string.
+        return JSON.stringify(data, null, 2) ?? 'null';
+    }
+    catch (e) {
+        return JSON.stringify({ error: 'unserializable', message: e instanceof Error ? e.message : String(e) }, null, 2);
+    }
+}
+export function createOutput(opts) {
+    const out = (data) => {
+        if (opts.quiet)
+            return;
+        if (opts.format === 'table') {
+            process.stdout.write(`${renderTable(data)}\n`);
+        }
+        else {
+            process.stdout.write(`${safeJsonStringify(data)}\n`);
+        }
+    };
+    const err = (message) => {
+        if (!opts.quiet)
+            process.stderr.write(`Error: ${message}\n`);
+    };
+    return { out, err };
+}
+//# sourceMappingURL=output.js.map

package/dist/cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-export {};
+import './cli/index.js';
 //# sourceMappingURL=cli.d.ts.map