chartsplat 1.0.0

package/README.md

@@ -0,0 +1,311 @@
+# chartsplat
+
+Official TypeScript/JavaScript client for [Chart Splat](https://chartsplat.com) - Generate beautiful charts via API.
+
+## Installation
+
+```bash
+npm install chartsplat
+```
+
+## Quick Start
+
+```typescript
+import { ChartSplat } from 'chartsplat';
+
+const client = new ChartSplat('YOUR_API_KEY');
+
+// Generate a bar chart
+const chart = await client.generateChart({
+  type: 'bar',
+  data: {
+    labels: ['Jan', 'Feb', 'Mar', 'Apr'],
+    datasets: [{
+      label: 'Revenue',
+      data: [12, 19, 3, 5],
+      backgroundColor: '#8b5cf6'
+    }]
+  }
+});
+
+// Use the base64 image
+console.log(chart.image); // data:image/png;base64,...
+
+// Use in HTML
+const img = document.createElement('img');
+img.src = chart.image;
+```
+
+## Features
+
+- Full TypeScript support
+- Works in Node.js (18+) and browsers
+- Convenience methods for all chart types
+- Rate limit tracking
+- Timeout handling
+- Custom fetch support for older Node.js versions
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { ChartSplat } from 'chartsplat';
+
+const client = new ChartSplat('cs_your_api_key');
+
+const chart = await client.generateChart({
+  type: 'line',
+  data: {
+    labels: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
+    datasets: [{
+      label: 'Visitors',
+      data: [100, 200, 150, 300, 250],
+      borderColor: '#3b82f6',
+      fill: false
+    }]
+  },
+  options: {
+    width: 1200,
+    height: 800
+  }
+});
+```
+
+### Convenience Methods
+
+```typescript
+// Line chart
+const lineChart = await client.lineChart({
+  labels: ['A', 'B', 'C'],
+  datasets: [{ data: [1, 2, 3], borderColor: '#3b82f6' }]
+});
+
+// Bar chart
+const barChart = await client.barChart({
+  labels: ['A', 'B', 'C'],
+  datasets: [{ data: [1, 2, 3], backgroundColor: '#8b5cf6' }]
+});
+
+// Pie chart
+const pieChart = await client.pieChart({
+  labels: ['Red', 'Blue', 'Yellow'],
+  datasets: [{ data: [30, 50, 20], backgroundColor: ['#ef4444', '#3b82f6', '#eab308'] }]
+});
+
+// Doughnut chart
+const doughnutChart = await client.doughnutChart({
+  labels: ['Desktop', 'Mobile'],
+  datasets: [{ data: [60, 40], backgroundColor: ['#8b5cf6', '#ec4899'] }]
+});
+
+// Radar chart
+const radarChart = await client.radarChart({
+  labels: ['Speed', 'Power', 'Range'],
+  datasets: [{ label: 'Player', data: [65, 59, 90], borderColor: '#f59e0b' }]
+});
+
+// Polar area chart
+const polarChart = await client.polarAreaChart({
+  labels: ['Red', 'Green', 'Blue'],
+  datasets: [{ data: [11, 16, 7], backgroundColor: ['#ef4444', '#10b981', '#3b82f6'] }]
+});
+```
+
+### Save to File (Node.js)
+
+```typescript
+import fs from 'fs';
+import { ChartSplat } from 'chartsplat';
+
+const client = new ChartSplat('cs_your_api_key');
+
+const chart = await client.generateChart({
+  type: 'bar',
+  data: {
+    labels: ['A', 'B', 'C'],
+    datasets: [{ data: [1, 2, 3] }]
+  }
+});
+
+// Remove the data URI prefix and decode
+const base64Data = chart.image.replace(/^data:image\/png;base64,/, '');
+fs.writeFileSync('chart.png', Buffer.from(base64Data, 'base64'));
+```
+
+### React Example
+
+```tsx
+import { ChartSplat } from 'chartsplat';
+import { useState, useEffect } from 'react';
+
+const client = new ChartSplat('cs_your_api_key');
+
+function MyChart() {
+  const [chartUrl, setChartUrl] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    async function loadChart() {
+      try {
+        const chart = await client.generateChart({
+          type: 'line',
+          data: {
+            labels: ['Jan', 'Feb', 'Mar'],
+            datasets: [{
+              label: 'Sales',
+              data: [100, 200, 150],
+              borderColor: '#ec4899'
+            }]
+          }
+        });
+        setChartUrl(chart.image);
+      } catch (err) {
+        setError(err.message);
+      }
+    }
+    loadChart();
+  }, []);
+
+  if (error) return <div>Error: {error}</div>;
+  if (!chartUrl) return <div>Loading...</div>;
+  return <img src={chartUrl} alt="Chart" />;
+}
+```
+
+### Rate Limit Handling
+
+```typescript
+import { ChartSplat, ChartSplatAPIError } from 'chartsplat';
+
+const client = new ChartSplat('cs_your_api_key');
+
+try {
+  const chart = await client.generateChart({ /* ... */ });
+
+  // Check rate limit after request
+  const rateLimit = client.getRateLimit();
+  console.log(`${rateLimit.remaining}/${rateLimit.limit} requests remaining`);
+  console.log(`Resets at: ${rateLimit.reset}`);
+} catch (error) {
+  if (error instanceof ChartSplatAPIError && error.status === 429) {
+    console.log('Rate limited!');
+    console.log(`Limit: ${error.rateLimit?.limit}`);
+    console.log(`Resets at: ${error.rateLimit?.reset}`);
+  }
+}
+```
+
+### Custom Configuration
+
+```typescript
+import { ChartSplat } from 'chartsplat';
+
+const client = new ChartSplat('cs_your_api_key', {
+  // Custom base URL (for local development)
+  baseUrl: 'http://localhost:3001',
+
+  // Request timeout in milliseconds
+  timeout: 60000,
+
+  // Custom fetch (for Node.js < 18)
+  fetch: require('node-fetch'),
+});
+```
+
+## API Reference
+
+### `ChartSplat` Class
+
+#### Constructor
+
+```typescript
+new ChartSplat(apiKey: string, options?: ChartSplatOptions)
+```
+
+- `apiKey` - Your Chart Splat API key (starts with `cs_`)
+- `options.baseUrl` - Base URL for the API (default: `https://api.chartsplat.com`)
+- `options.timeout` - Request timeout in ms (default: `30000`)
+- `options.fetch` - Custom fetch implementation
+
+#### Methods
+
+- `generateChart(request: ChartRequest): Promise<ChartResponse>` - Generate any chart type
+- `lineChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a line chart
+- `barChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a bar chart
+- `pieChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a pie chart
+- `doughnutChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a doughnut chart
+- `radarChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a radar chart
+- `polarAreaChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>` - Generate a polar area chart
+- `getRateLimit(): RateLimitInfo | undefined` - Get rate limit info from last request
+
+### Types
+
+```typescript
+interface ChartRequest {
+  type?: 'line' | 'bar' | 'pie' | 'doughnut' | 'radar' | 'polarArea';
+  data: ChartData;
+  options?: ChartOptions;
+}
+
+interface ChartData {
+  labels: string[];
+  datasets: Dataset[];
+}
+
+interface Dataset {
+  label?: string;
+  data: number[];
+  backgroundColor?: string | string[];
+  borderColor?: string | string[];
+  borderWidth?: number;
+  fill?: boolean;
+}
+
+interface ChartOptions {
+  width?: number;  // Default: 800
+  height?: number; // Default: 600
+  plugins?: Record<string, unknown>;
+  scales?: Record<string, unknown>;
+}
+
+interface ChartResponse {
+  image: string;   // Base64 PNG with data URI prefix
+  format: 'png';
+  width: number;
+  height: number;
+}
+```
+
+## Error Handling
+
+The client throws typed errors for different failure scenarios:
+
+```typescript
+import { ChartSplat, ChartSplatAPIError, ChartSplatTimeoutError } from 'chartsplat';
+
+try {
+  const chart = await client.generateChart({ /* ... */ });
+} catch (error) {
+  if (error instanceof ChartSplatAPIError) {
+    console.log('API Error:', error.message);
+    console.log('Status:', error.status);
+    console.log('Code:', error.code);
+  } else if (error instanceof ChartSplatTimeoutError) {
+    console.log('Request timed out');
+  } else {
+    console.log('Unknown error:', error);
+  }
+}
+```
+
+## License
+
+MIT - see [LICENSE](./LICENSE) for details.
+
+## Links
+
+- [Website](https://chartsplat.com)
+- [Documentation](https://chartsplat.com/docs)
+- [Pricing](https://chartsplat.com/pricing)
+- [OpenAPI Spec](https://chartsplat.com/openapi.yaml)

package/dist/index.d.mts

@@ -0,0 +1,246 @@
+/**
+ * Chart Splat - Official TypeScript/JavaScript Client
+ *
+ * Generate beautiful charts via API using Chart.js configuration.
+ *
+ * @example
+ * ```typescript
+ * import { ChartSplat } from 'chartsplat';
+ *
+ * const client = new ChartSplat('YOUR_API_KEY');
+ *
+ * const chart = await client.generateChart({
+ *   type: 'bar',
+ *   data: {
+ *     labels: ['Jan', 'Feb', 'Mar'],
+ *     datasets: [{
+ *       label: 'Revenue',
+ *       data: [12, 19, 3],
+ *       backgroundColor: '#8b5cf6'
+ *     }]
+ *   }
+ * });
+ *
+ * console.log(chart.image); // data:image/png;base64,...
+ * ```
+ */
+/** Chart types supported by Chart Splat */
+type ChartType = 'line' | 'bar' | 'pie' | 'doughnut' | 'radar' | 'polarArea';
+/** Dataset configuration for a chart */
+interface Dataset {
+    /** Label for the dataset (shown in legend) */
+    label?: string;
+    /** Data points for the dataset */
+    data: number[];
+    /** Background color(s) for the dataset */
+    backgroundColor?: string | string[];
+    /** Border color(s) for the dataset */
+    borderColor?: string | string[];
+    /** Border width in pixels */
+    borderWidth?: number;
+    /** Whether to fill the area under line charts */
+    fill?: boolean;
+    /** Additional Chart.js dataset options */
+    [key: string]: unknown;
+}
+/** Chart data configuration */
+interface ChartData {
+    /** Labels for the X-axis or segments */
+    labels: string[];
+    /** Array of datasets to display */
+    datasets: Dataset[];
+}
+/** Chart options configuration */
+interface ChartOptions {
+    /** Image width in pixels (default: 800) */
+    width?: number;
+    /** Image height in pixels (default: 600) */
+    height?: number;
+    /** Chart.js plugin options */
+    plugins?: Record<string, unknown>;
+    /** Chart.js scale options */
+    scales?: Record<string, unknown>;
+    /** Additional Chart.js options */
+    [key: string]: unknown;
+}
+/** Request payload for chart generation */
+interface ChartRequest {
+    /** The type of chart to generate (default: 'line') */
+    type?: ChartType;
+    /** Chart data configuration */
+    data: ChartData;
+    /** Chart options */
+    options?: ChartOptions;
+}
+/** Response from chart generation */
+interface ChartResponse {
+    /** Base64-encoded PNG image with data URI prefix */
+    image: string;
+    /** Image format (always 'png') */
+    format: 'png';
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+}
+/** Error response from the API */
+interface ChartSplatError {
+    /** Error type or message */
+    error: string;
+    /** Detailed error message */
+    message?: string;
+    /** Rate limit (if applicable) */
+    limit?: number;
+    /** Requests used (if applicable) */
+    used?: number;
+    /** Current plan (if applicable) */
+    plan?: string;
+}
+/** Rate limit information from response headers */
+interface RateLimitInfo {
+    /** Monthly request limit */
+    limit: number;
+    /** Requests remaining this month */
+    remaining: number;
+    /** When the limit resets (ISO 8601 date) */
+    reset: string;
+}
+/** Options for the ChartSplat client */
+interface ChartSplatOptions {
+    /** Base URL for the API (default: https://api.chartsplat.com) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Custom fetch implementation (for Node.js < 18 or testing) */
+    fetch?: typeof fetch;
+}
+/** Error thrown when the API returns an error response */
+declare class ChartSplatAPIError extends Error {
+    /** HTTP status code */
+    readonly status: number;
+    /** Error code from the API */
+    readonly code: string;
+    /** Rate limit info (if rate limited) */
+    readonly rateLimit?: RateLimitInfo;
+    constructor(message: string, status: number, code: string, rateLimit?: RateLimitInfo);
+}
+/** Error thrown when a request times out */
+declare class ChartSplatTimeoutError extends Error {
+    constructor(timeout: number);
+}
+/**
+ * Chart Splat API Client
+ *
+ * @example
+ * ```typescript
+ * const client = new ChartSplat('YOUR_API_KEY');
+ *
+ * // Generate a simple bar chart
+ * const chart = await client.generateChart({
+ *   type: 'bar',
+ *   data: {
+ *     labels: ['A', 'B', 'C'],
+ *     datasets: [{ data: [1, 2, 3] }]
+ *   }
+ * });
+ * ```
+ */
+declare class ChartSplat {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly fetchFn;
+    /** Rate limit info from the last request */
+    lastRateLimit?: RateLimitInfo;
+    /**
+     * Create a new Chart Splat client
+     *
+     * @param apiKey - Your Chart Splat API key (starts with 'cs_')
+     * @param options - Client configuration options
+     */
+    constructor(apiKey: string, options?: ChartSplatOptions);
+    /**
+     * Generate a chart image
+     *
+     * @param request - Chart configuration
+     * @returns Chart response with base64 image
+     * @throws {ChartSplatAPIError} If the API returns an error
+     * @throws {ChartSplatTimeoutError} If the request times out
+     *
+     * @example
+     * ```typescript
+     * const chart = await client.generateChart({
+     *   type: 'line',
+     *   data: {
+     *     labels: ['Jan', 'Feb', 'Mar'],
+     *     datasets: [{
+     *       label: 'Sales',
+     *       data: [100, 200, 150],
+     *       borderColor: '#3b82f6'
+     *     }]
+     *   },
+     *   options: {
+     *     width: 1200,
+     *     height: 800
+     *   }
+     * });
+     * ```
+     */
+    generateChart(request: ChartRequest): Promise<ChartResponse>;
+    /**
+     * Generate a line chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    lineChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a bar chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    barChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a pie chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    pieChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a doughnut chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    doughnutChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a radar chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    radarChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a polar area chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    polarAreaChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Get rate limit information from the last request
+     *
+     * @returns Rate limit info or undefined if no request has been made
+     */
+    getRateLimit(): RateLimitInfo | undefined;
+}
+
+export { type ChartData, type ChartOptions, type ChartRequest, type ChartResponse, ChartSplat, ChartSplatAPIError, type ChartSplatError, type ChartSplatOptions, ChartSplatTimeoutError, type ChartType, type Dataset, type RateLimitInfo, ChartSplat as default };

package/dist/index.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Chart Splat - Official TypeScript/JavaScript Client
+ *
+ * Generate beautiful charts via API using Chart.js configuration.
+ *
+ * @example
+ * ```typescript
+ * import { ChartSplat } from 'chartsplat';
+ *
+ * const client = new ChartSplat('YOUR_API_KEY');
+ *
+ * const chart = await client.generateChart({
+ *   type: 'bar',
+ *   data: {
+ *     labels: ['Jan', 'Feb', 'Mar'],
+ *     datasets: [{
+ *       label: 'Revenue',
+ *       data: [12, 19, 3],
+ *       backgroundColor: '#8b5cf6'
+ *     }]
+ *   }
+ * });
+ *
+ * console.log(chart.image); // data:image/png;base64,...
+ * ```
+ */
+/** Chart types supported by Chart Splat */
+type ChartType = 'line' | 'bar' | 'pie' | 'doughnut' | 'radar' | 'polarArea';
+/** Dataset configuration for a chart */
+interface Dataset {
+    /** Label for the dataset (shown in legend) */
+    label?: string;
+    /** Data points for the dataset */
+    data: number[];
+    /** Background color(s) for the dataset */
+    backgroundColor?: string | string[];
+    /** Border color(s) for the dataset */
+    borderColor?: string | string[];
+    /** Border width in pixels */
+    borderWidth?: number;
+    /** Whether to fill the area under line charts */
+    fill?: boolean;
+    /** Additional Chart.js dataset options */
+    [key: string]: unknown;
+}
+/** Chart data configuration */
+interface ChartData {
+    /** Labels for the X-axis or segments */
+    labels: string[];
+    /** Array of datasets to display */
+    datasets: Dataset[];
+}
+/** Chart options configuration */
+interface ChartOptions {
+    /** Image width in pixels (default: 800) */
+    width?: number;
+    /** Image height in pixels (default: 600) */
+    height?: number;
+    /** Chart.js plugin options */
+    plugins?: Record<string, unknown>;
+    /** Chart.js scale options */
+    scales?: Record<string, unknown>;
+    /** Additional Chart.js options */
+    [key: string]: unknown;
+}
+/** Request payload for chart generation */
+interface ChartRequest {
+    /** The type of chart to generate (default: 'line') */
+    type?: ChartType;
+    /** Chart data configuration */
+    data: ChartData;
+    /** Chart options */
+    options?: ChartOptions;
+}
+/** Response from chart generation */
+interface ChartResponse {
+    /** Base64-encoded PNG image with data URI prefix */
+    image: string;
+    /** Image format (always 'png') */
+    format: 'png';
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+}
+/** Error response from the API */
+interface ChartSplatError {
+    /** Error type or message */
+    error: string;
+    /** Detailed error message */
+    message?: string;
+    /** Rate limit (if applicable) */
+    limit?: number;
+    /** Requests used (if applicable) */
+    used?: number;
+    /** Current plan (if applicable) */
+    plan?: string;
+}
+/** Rate limit information from response headers */
+interface RateLimitInfo {
+    /** Monthly request limit */
+    limit: number;
+    /** Requests remaining this month */
+    remaining: number;
+    /** When the limit resets (ISO 8601 date) */
+    reset: string;
+}
+/** Options for the ChartSplat client */
+interface ChartSplatOptions {
+    /** Base URL for the API (default: https://api.chartsplat.com) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Custom fetch implementation (for Node.js < 18 or testing) */
+    fetch?: typeof fetch;
+}
+/** Error thrown when the API returns an error response */
+declare class ChartSplatAPIError extends Error {
+    /** HTTP status code */
+    readonly status: number;
+    /** Error code from the API */
+    readonly code: string;
+    /** Rate limit info (if rate limited) */
+    readonly rateLimit?: RateLimitInfo;
+    constructor(message: string, status: number, code: string, rateLimit?: RateLimitInfo);
+}
+/** Error thrown when a request times out */
+declare class ChartSplatTimeoutError extends Error {
+    constructor(timeout: number);
+}
+/**
+ * Chart Splat API Client
+ *
+ * @example
+ * ```typescript
+ * const client = new ChartSplat('YOUR_API_KEY');
+ *
+ * // Generate a simple bar chart
+ * const chart = await client.generateChart({
+ *   type: 'bar',
+ *   data: {
+ *     labels: ['A', 'B', 'C'],
+ *     datasets: [{ data: [1, 2, 3] }]
+ *   }
+ * });
+ * ```
+ */
+declare class ChartSplat {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly fetchFn;
+    /** Rate limit info from the last request */
+    lastRateLimit?: RateLimitInfo;
+    /**
+     * Create a new Chart Splat client
+     *
+     * @param apiKey - Your Chart Splat API key (starts with 'cs_')
+     * @param options - Client configuration options
+     */
+    constructor(apiKey: string, options?: ChartSplatOptions);
+    /**
+     * Generate a chart image
+     *
+     * @param request - Chart configuration
+     * @returns Chart response with base64 image
+     * @throws {ChartSplatAPIError} If the API returns an error
+     * @throws {ChartSplatTimeoutError} If the request times out
+     *
+     * @example
+     * ```typescript
+     * const chart = await client.generateChart({
+     *   type: 'line',
+     *   data: {
+     *     labels: ['Jan', 'Feb', 'Mar'],
+     *     datasets: [{
+     *       label: 'Sales',
+     *       data: [100, 200, 150],
+     *       borderColor: '#3b82f6'
+     *     }]
+     *   },
+     *   options: {
+     *     width: 1200,
+     *     height: 800
+     *   }
+     * });
+     * ```
+     */
+    generateChart(request: ChartRequest): Promise<ChartResponse>;
+    /**
+     * Generate a line chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    lineChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a bar chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    barChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a pie chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    pieChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a doughnut chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    doughnutChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a radar chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    radarChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Generate a polar area chart
+     *
+     * @param data - Chart data
+     * @param options - Chart options
+     * @returns Chart response with base64 image
+     */
+    polarAreaChart(data: ChartData, options?: ChartOptions): Promise<ChartResponse>;
+    /**
+     * Get rate limit information from the last request
+     *
+     * @returns Rate limit info or undefined if no request has been made
+     */
+    getRateLimit(): RateLimitInfo | undefined;
+}
+
+export { type ChartData, type ChartOptions, type ChartRequest, type ChartResponse, ChartSplat, ChartSplatAPIError, type ChartSplatError, type ChartSplatOptions, ChartSplatTimeoutError, type ChartType, type Dataset, type RateLimitInfo, ChartSplat as default };

package/dist/index.js

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChartSplat: () => ChartSplat,
+  ChartSplatAPIError: () => ChartSplatAPIError,
+  ChartSplatTimeoutError: () => ChartSplatTimeoutError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var ChartSplatAPIError = class extends Error {
+  constructor(message, status, code, rateLimit) {
+    super(message);
+    this.name = "ChartSplatAPIError";
+    this.status = status;
+    this.code = code;
+    this.rateLimit = rateLimit;
+  }
+};
+var ChartSplatTimeoutError = class extends Error {
+  constructor(timeout) {
+    super(`Request timed out after ${timeout}ms`);
+    this.name = "ChartSplatTimeoutError";
+  }
+};
+var ChartSplat = class {
+  /**
+   * Create a new Chart Splat client
+   *
+   * @param apiKey - Your Chart Splat API key (starts with 'cs_')
+   * @param options - Client configuration options
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!apiKey.startsWith("cs_")) {
+      throw new Error('Invalid API key format. API keys start with "cs_"');
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl || "https://api.chartsplat.com";
+    this.timeout = options.timeout || 3e4;
+    this.fetchFn = options.fetch || globalThis.fetch;
+    if (!this.fetchFn) {
+      throw new Error(
+        "fetch is not available. Please provide a fetch implementation or upgrade to Node.js 18+"
+      );
+    }
+  }
+  /**
+   * Generate a chart image
+   *
+   * @param request - Chart configuration
+   * @returns Chart response with base64 image
+   * @throws {ChartSplatAPIError} If the API returns an error
+   * @throws {ChartSplatTimeoutError} If the request times out
+   *
+   * @example
+   * ```typescript
+   * const chart = await client.generateChart({
+   *   type: 'line',
+   *   data: {
+   *     labels: ['Jan', 'Feb', 'Mar'],
+   *     datasets: [{
+   *       label: 'Sales',
+   *       data: [100, 200, 150],
+   *       borderColor: '#3b82f6'
+   *     }]
+   *   },
+   *   options: {
+   *     width: 1200,
+   *     height: 800
+   *   }
+   * });
+   * ```
+   */
+  async generateChart(request) {
+    if (!request.data) {
+      throw new Error("data is required");
+    }
+    if (!request.data.labels || !Array.isArray(request.data.labels)) {
+      throw new Error("data.labels is required and must be an array");
+    }
+    if (!request.data.datasets || !Array.isArray(request.data.datasets)) {
+      throw new Error("data.datasets is required and must be an array");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(`${this.baseUrl}/chart`, {
+        method: "POST",
+        headers: {
+          "X-Api-Key": this.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      this.lastRateLimit = {
+        limit: parseInt(response.headers.get("X-RateLimit-Limit") || "0", 10),
+        remaining: parseInt(response.headers.get("X-RateLimit-Remaining") || "0", 10),
+        reset: response.headers.get("X-RateLimit-Reset") || ""
+      };
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new ChartSplatAPIError(
+          errorData.message || errorData.error,
+          response.status,
+          errorData.error,
+          response.status === 429 ? this.lastRateLimit : void 0
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ChartSplatAPIError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ChartSplatTimeoutError(this.timeout);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Generate a line chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async lineChart(data, options) {
+    return this.generateChart({ type: "line", data, options });
+  }
+  /**
+   * Generate a bar chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async barChart(data, options) {
+    return this.generateChart({ type: "bar", data, options });
+  }
+  /**
+   * Generate a pie chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async pieChart(data, options) {
+    return this.generateChart({ type: "pie", data, options });
+  }
+  /**
+   * Generate a doughnut chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async doughnutChart(data, options) {
+    return this.generateChart({ type: "doughnut", data, options });
+  }
+  /**
+   * Generate a radar chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async radarChart(data, options) {
+    return this.generateChart({ type: "radar", data, options });
+  }
+  /**
+   * Generate a polar area chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async polarAreaChart(data, options) {
+    return this.generateChart({ type: "polarArea", data, options });
+  }
+  /**
+   * Get rate limit information from the last request
+   *
+   * @returns Rate limit info or undefined if no request has been made
+   */
+  getRateLimit() {
+    return this.lastRateLimit;
+  }
+};
+var index_default = ChartSplat;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChartSplat,
+  ChartSplatAPIError,
+  ChartSplatTimeoutError
+});

package/dist/index.mjs

@@ -0,0 +1,192 @@
+// src/index.ts
+var ChartSplatAPIError = class extends Error {
+  constructor(message, status, code, rateLimit) {
+    super(message);
+    this.name = "ChartSplatAPIError";
+    this.status = status;
+    this.code = code;
+    this.rateLimit = rateLimit;
+  }
+};
+var ChartSplatTimeoutError = class extends Error {
+  constructor(timeout) {
+    super(`Request timed out after ${timeout}ms`);
+    this.name = "ChartSplatTimeoutError";
+  }
+};
+var ChartSplat = class {
+  /**
+   * Create a new Chart Splat client
+   *
+   * @param apiKey - Your Chart Splat API key (starts with 'cs_')
+   * @param options - Client configuration options
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!apiKey.startsWith("cs_")) {
+      throw new Error('Invalid API key format. API keys start with "cs_"');
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl || "https://api.chartsplat.com";
+    this.timeout = options.timeout || 3e4;
+    this.fetchFn = options.fetch || globalThis.fetch;
+    if (!this.fetchFn) {
+      throw new Error(
+        "fetch is not available. Please provide a fetch implementation or upgrade to Node.js 18+"
+      );
+    }
+  }
+  /**
+   * Generate a chart image
+   *
+   * @param request - Chart configuration
+   * @returns Chart response with base64 image
+   * @throws {ChartSplatAPIError} If the API returns an error
+   * @throws {ChartSplatTimeoutError} If the request times out
+   *
+   * @example
+   * ```typescript
+   * const chart = await client.generateChart({
+   *   type: 'line',
+   *   data: {
+   *     labels: ['Jan', 'Feb', 'Mar'],
+   *     datasets: [{
+   *       label: 'Sales',
+   *       data: [100, 200, 150],
+   *       borderColor: '#3b82f6'
+   *     }]
+   *   },
+   *   options: {
+   *     width: 1200,
+   *     height: 800
+   *   }
+   * });
+   * ```
+   */
+  async generateChart(request) {
+    if (!request.data) {
+      throw new Error("data is required");
+    }
+    if (!request.data.labels || !Array.isArray(request.data.labels)) {
+      throw new Error("data.labels is required and must be an array");
+    }
+    if (!request.data.datasets || !Array.isArray(request.data.datasets)) {
+      throw new Error("data.datasets is required and must be an array");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(`${this.baseUrl}/chart`, {
+        method: "POST",
+        headers: {
+          "X-Api-Key": this.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request),
+        signal: controller.signal
+      });
+      this.lastRateLimit = {
+        limit: parseInt(response.headers.get("X-RateLimit-Limit") || "0", 10),
+        remaining: parseInt(response.headers.get("X-RateLimit-Remaining") || "0", 10),
+        reset: response.headers.get("X-RateLimit-Reset") || ""
+      };
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new ChartSplatAPIError(
+          errorData.message || errorData.error,
+          response.status,
+          errorData.error,
+          response.status === 429 ? this.lastRateLimit : void 0
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof ChartSplatAPIError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ChartSplatTimeoutError(this.timeout);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Generate a line chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async lineChart(data, options) {
+    return this.generateChart({ type: "line", data, options });
+  }
+  /**
+   * Generate a bar chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async barChart(data, options) {
+    return this.generateChart({ type: "bar", data, options });
+  }
+  /**
+   * Generate a pie chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async pieChart(data, options) {
+    return this.generateChart({ type: "pie", data, options });
+  }
+  /**
+   * Generate a doughnut chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async doughnutChart(data, options) {
+    return this.generateChart({ type: "doughnut", data, options });
+  }
+  /**
+   * Generate a radar chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async radarChart(data, options) {
+    return this.generateChart({ type: "radar", data, options });
+  }
+  /**
+   * Generate a polar area chart
+   *
+   * @param data - Chart data
+   * @param options - Chart options
+   * @returns Chart response with base64 image
+   */
+  async polarAreaChart(data, options) {
+    return this.generateChart({ type: "polarArea", data, options });
+  }
+  /**
+   * Get rate limit information from the last request
+   *
+   * @returns Rate limit info or undefined if no request has been made
+   */
+  getRateLimit() {
+    return this.lastRateLimit;
+  }
+};
+var index_default = ChartSplat;
+export {
+  ChartSplat,
+  ChartSplatAPIError,
+  ChartSplatTimeoutError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "chartsplat",
+  "version": "1.0.0",
+  "description": "Official TypeScript/JavaScript client for Chart Splat API - Generate beautiful charts via API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "chart",
+    "charts",
+    "chartjs",
+    "chart.js",
+    "api",
+    "image",
+    "png",
+    "visualization",
+    "data-visualization",
+    "chartsplat"
+  ],
+  "author": "Chart Splat",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chartsplat/chartsplat.git",
+    "directory": "packages/chartsplat"
+  },
+  "bugs": {
+    "url": "https://github.com/chartsplat/chartsplat/issues"
+  },
+  "homepage": "https://chartsplat.com",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}