@proveanything/smartlinks 1.8.1 → 1.8.2

package/dist/http.js

@@ -13,6 +13,18 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 import { SmartlinksApiError, SmartlinksOfflineError } from "./types/error";
 import { idbGet, idbSet, idbClear } from './persistentCache';
 let baseURL = null;
@@ -514,15 +526,178 @@ export function invalidateCache(urlPattern) {
 }
 // Map of pending proxy requests: id -> {resolve, reject}
 const proxyPending = {};
+const proxyStreamPending = new Map();
 function generateProxyId() {
     return "proxy_" + Math.random().toString(36).slice(2) + Date.now();
 }
+async function createFetchError(response, url) {
+    let responseBody;
+    try {
+        responseBody = await response.json();
+    }
+    catch (_a) {
+        responseBody = null;
+    }
+    const errBody = normalizeErrorResponse(responseBody, response.status);
+    return new SmartlinksApiError(`Error ${errBody.code}: ${errBody.message}`, response.status, errBody, url);
+}
+function createProxyStreamIterable(id) {
+    const queue = [];
+    const waiters = [];
+    let done = false;
+    let failure = null;
+    const flushDone = () => {
+        while (waiters.length) {
+            const waiter = waiters.shift();
+            waiter === null || waiter === void 0 ? void 0 : waiter.resolve({ value: undefined, done: true });
+        }
+    };
+    const flushError = (error) => {
+        while (waiters.length) {
+            const waiter = waiters.shift();
+            waiter === null || waiter === void 0 ? void 0 : waiter.reject(error);
+        }
+    };
+    const iterator = {
+        next() {
+            if (queue.length) {
+                return Promise.resolve({ value: queue.shift(), done: false });
+            }
+            if (failure) {
+                return Promise.reject(failure);
+            }
+            if (done) {
+                return Promise.resolve({ value: undefined, done: true });
+            }
+            return new Promise((resolve, reject) => {
+                waiters.push({ resolve, reject });
+            });
+        },
+        async return() {
+            if (!done && !failure) {
+                done = true;
+                proxyStreamPending.delete(id);
+                try {
+                    window.parent.postMessage({ _smartlinksProxyStreamAbort: true, id }, '*');
+                }
+                catch (_a) { }
+            }
+            flushDone();
+            return { value: undefined, done: true };
+        },
+        async throw(error) {
+            failure = error || new Error('Proxy stream failed');
+            done = true;
+            proxyStreamPending.delete(id);
+            flushError(failure);
+            throw failure;
+        },
+    };
+    return {
+        push(value) {
+            if (done || failure)
+                return;
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter.resolve({ value, done: false });
+                return;
+            }
+            queue.push(value);
+        },
+        finish() {
+            if (done || failure)
+                return;
+            done = true;
+            proxyStreamPending.delete(id);
+            flushDone();
+        },
+        fail(error) {
+            if (done || failure)
+                return;
+            failure = error;
+            done = true;
+            proxyStreamPending.delete(id);
+            flushError(error);
+        },
+        iterable: {
+            [Symbol.asyncIterator]() {
+                return iterator;
+            },
+        },
+    };
+}
+function parseSsePayload(payload) {
+    if (!payload || payload === '[DONE]')
+        return undefined;
+    try {
+        return JSON.parse(payload);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function parseSseStream(stream) {
+    return __asyncGenerator(this, arguments, function* parseSseStream_1() {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let dataLines = [];
+        while (true) {
+            const { done, value } = yield __await(reader.read());
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() || '';
+            for (const rawLine of lines) {
+                const line = rawLine.trimEnd();
+                if (!line) {
+                    if (!dataLines.length)
+                        continue;
+                    const parsed = parseSsePayload(dataLines.join('\n'));
+                    dataLines = [];
+                    if (parsed !== undefined) {
+                        yield yield __await(parsed);
+                    }
+                    continue;
+                }
+                if (line.startsWith('data:')) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+            }
+        }
+        if (dataLines.length) {
+            const parsed = parseSsePayload(dataLines.join('\n'));
+            if (parsed !== undefined) {
+                yield yield __await(parsed);
+            }
+        }
+    });
+}
 // Shared listener for proxy responses
 function ensureProxyListener() {
     if (window._smartlinksProxyListener)
         return;
     window.addEventListener("message", (event) => {
         const msg = event.data;
+        if ((msg === null || msg === void 0 ? void 0 : msg._smartlinksProxyStream) && msg.id) {
+            const pendingStream = proxyStreamPending.get(msg.id);
+            if (!pendingStream)
+                return;
+            if (msg.phase === 'event') {
+                pendingStream.push(msg.data);
+                return;
+            }
+            if (msg.phase === 'end') {
+                pendingStream.finish();
+                return;
+            }
+            if (msg.phase === 'error') {
+                pendingStream.fail(new Error(msg.error || 'Proxy stream failed'));
+                return;
+            }
+            return;
+        }
         if (!msg || !msg._smartlinksProxyResponse || !msg.id)
             return;
         logDebug('[smartlinks] proxy:response', { id: msg.id, ok: !msg.error, keys: Object.keys(msg) });
@@ -539,6 +714,32 @@ function ensureProxyListener() {
     });
     window._smartlinksProxyListener = true;
 }
+async function proxyStreamRequest(method, path, body, headers) {
+    ensureProxyListener();
+    const payloadBody = (typeof FormData !== 'undefined' && body instanceof FormData)
+        ? serializeFormDataForProxy(body)
+        : body;
+    const id = generateProxyId();
+    const streamController = createProxyStreamIterable(id);
+    proxyStreamPending.set(id, streamController);
+    const msg = {
+        _smartlinksProxyStreamRequest: true,
+        id,
+        method,
+        path,
+        body: payloadBody,
+        headers,
+    };
+    logDebug('[smartlinks] proxy:stream postMessage', {
+        id,
+        method,
+        path,
+        headers: headers ? redactHeaders(headers) : undefined,
+        hasBody: !!body,
+    });
+    window.parent.postMessage(msg, '*');
+    return streamController.iterable;
+}
 // Proxy request implementation
 function serializeFormDataForProxy(fd) {
     const entries = [];
@@ -1105,6 +1306,41 @@ export async function requestWithOptions(path, options) {
     }
     return fetchPromise;
 }
+/**
+ * Internal helper that performs a streaming request using the shared auth and proxy transport.
+ * The response is expected to be `text/event-stream` with JSON payloads in `data:` frames.
+ */
+export async function requestStream(path, options) {
+    const method = (options === null || options === void 0 ? void 0 : options.method) || 'POST';
+    const body = options === null || options === void 0 ? void 0 : options.body;
+    const extraHeaders = (options === null || options === void 0 ? void 0 : options.headers) || {};
+    const headers = Object.assign(Object.assign(Object.assign({}, extraHeaders), getApiHeaders()), { Accept: 'text/event-stream' });
+    if (!(typeof FormData !== 'undefined' && body instanceof FormData) && body !== undefined && !Object.keys(headers).some(k => k.toLowerCase() === 'content-type')) {
+        headers['Content-Type'] = 'application/json';
+    }
+    if (proxyMode) {
+        logDebug('[smartlinks] stream via proxy', { path, method });
+        return proxyStreamRequest(method, path, body, headers);
+    }
+    if (!baseURL) {
+        throw new Error("HTTP client is not initialized. Call initializeApi(...) first.");
+    }
+    const url = `${baseURL}${path}`;
+    logDebug('[smartlinks] stream fetch', { url, method, headers: redactHeaders(headers), body: safeBodyPreview(body) });
+    const response = await fetch(url, {
+        method,
+        headers,
+        body: body === undefined ? undefined : (body instanceof FormData ? body : JSON.stringify(body)),
+    });
+    logDebug('[smartlinks] stream response', { url, status: response.status, ok: response.ok });
+    if (!response.ok) {
+        throw await createFetchError(response, url);
+    }
+    if (!response.body) {
+        throw new Error('Streaming response body is unavailable in this environment');
+    }
+    return parseSseStream(response.body);
+}
 /**
  * Internal helper that performs a DELETE request to `${baseURL}${path}`,
  * injecting headers for apiKey or bearerToken if present.

package/dist/iframeResponder.d.ts

@@ -31,6 +31,7 @@ export declare class IframeResponder {
     private options;
     private cache;
     private uploads;
+    private activeStreams;
     private isInitialLoad;
     private messageHandler;
     private resizeHandler;
@@ -59,6 +60,9 @@ export declare class IframeResponder {
     private handleRouteChange;
     private handleStandardMessage;
     private handleProxyRequest;
+    private handleProxyStreamAbort;
+    private handleProxyStreamRequest;
+    private forwardProxyStream;
     private getCachedResponse;
     private handleUpload;
     private sendResponse;

package/dist/iframeResponder.js

@@ -35,6 +35,7 @@ export class IframeResponder {
     constructor(options) {
         this.iframe = null;
         this.uploads = new Map();
+        this.activeStreams = new Map();
         this.isInitialLoad = true;
         this.messageHandler = null;
         this.resizeHandler = null;
@@ -97,6 +98,8 @@ export class IframeResponder {
             this.resizeHandler = null;
         }
         this.uploads.clear();
+        this.activeStreams.forEach(controller => controller.abort());
+        this.activeStreams.clear();
         this.iframe = null;
     }
     // ===========================================================================
@@ -263,6 +266,16 @@ export class IframeResponder {
             await this.handleUpload(data, event);
             return;
         }
+        // Stream proxy aborts
+        if (data._smartlinksProxyStreamAbort) {
+            this.handleProxyStreamAbort(data);
+            return;
+        }
+        // Stream proxy requests
+        if (data._smartlinksProxyStreamRequest) {
+            await this.handleProxyStreamRequest(data, event);
+            return;
+        }
         // API proxy requests
         if (data._smartlinksProxyRequest || data._smartlinksCustomProxyRequest) {
             await this.handleProxyRequest(data, event);
@@ -426,6 +439,145 @@ export class IframeResponder {
         }
         this.sendResponse(event, response);
     }
+    handleProxyStreamAbort(data) {
+        const controller = this.activeStreams.get(data.id);
+        if (!controller) {
+            return;
+        }
+        controller.abort();
+        this.activeStreams.delete(data.id);
+    }
+    async handleProxyStreamRequest(data, event) {
+        var _a, _b, _c;
+        const controller = new AbortController();
+        this.activeStreams.set(data.id, controller);
+        try {
+            const path = data.path.startsWith('/') ? data.path.slice(1) : data.path;
+            const baseUrl = getBaseURL();
+            if (!baseUrl) {
+                throw new Error('SDK not initialized - call initializeApi() first');
+            }
+            const fetchOptions = {
+                method: data.method,
+                headers: data.headers,
+                signal: controller.signal,
+            };
+            if (data.body && data.method !== 'GET') {
+                fetchOptions.body = JSON.stringify(data.body);
+                fetchOptions.headers = Object.assign(Object.assign({}, fetchOptions.headers), { 'Content-Type': 'application/json' });
+            }
+            const response = await fetch(`${baseUrl}/${path}`, fetchOptions);
+            if (!response.ok) {
+                let responseBody = null;
+                try {
+                    responseBody = await response.json();
+                }
+                catch (_d) {
+                    responseBody = null;
+                }
+                const message = (responseBody === null || responseBody === void 0 ? void 0 : responseBody.message) || ((_a = responseBody === null || responseBody === void 0 ? void 0 : responseBody.error) === null || _a === void 0 ? void 0 : _a.message) || `Request failed with status ${response.status}`;
+                this.sendResponse(event, {
+                    _smartlinksProxyStream: true,
+                    id: data.id,
+                    phase: 'error',
+                    status: response.status,
+                    error: message,
+                });
+                return;
+            }
+            if (!response.body) {
+                throw new Error('Streaming response body is unavailable in this environment');
+            }
+            this.sendResponse(event, {
+                _smartlinksProxyStream: true,
+                id: data.id,
+                phase: 'open',
+            });
+            await this.forwardProxyStream(data.id, response.body, event);
+            this.sendResponse(event, {
+                _smartlinksProxyStream: true,
+                id: data.id,
+                phase: 'end',
+            });
+        }
+        catch (err) {
+            if ((err === null || err === void 0 ? void 0 : err.name) === 'AbortError') {
+                return;
+            }
+            console.error('[IframeResponder] Proxy stream error:', err);
+            this.sendResponse(event, {
+                _smartlinksProxyStream: true,
+                id: data.id,
+                phase: 'error',
+                error: (err === null || err === void 0 ? void 0 : err.message) || 'Unknown streaming error',
+            });
+            (_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, err);
+        }
+        finally {
+            this.activeStreams.delete(data.id);
+        }
+    }
+    async forwardProxyStream(id, stream, event) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let dataLines = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() || '';
+            for (const rawLine of lines) {
+                const line = rawLine.trimEnd();
+                if (!line) {
+                    if (!dataLines.length) {
+                        continue;
+                    }
+                    const payload = dataLines.join('\n');
+                    dataLines = [];
+                    if (payload === '[DONE]') {
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(payload);
+                        this.sendResponse(event, {
+                            _smartlinksProxyStream: true,
+                            id,
+                            phase: 'event',
+                            data: parsed,
+                        });
+                    }
+                    catch (_a) {
+                        // Ignore malformed event chunks
+                    }
+                    continue;
+                }
+                if (line.startsWith('data:')) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+            }
+        }
+        if (dataLines.length) {
+            const payload = dataLines.join('\n');
+            if (payload !== '[DONE]') {
+                try {
+                    const parsed = JSON.parse(payload);
+                    this.sendResponse(event, {
+                        _smartlinksProxyStream: true,
+                        id,
+                        phase: 'event',
+                        data: parsed,
+                    });
+                }
+                catch (_b) {
+                    // Ignore malformed trailing event chunk
+                }
+            }
+        }
+    }
     getCachedResponse(path) {
         // App data endpoints should NOT be cached - they need fresh data from API
         // These are the new separated app config endpoints

package/dist/openapi.yaml

@@ -15478,6 +15478,69 @@ components:
       required:
         - _smartlinksProxyResponse
         - id
+    ProxyStreamRequest:
+      type: object
+      properties:
+        _smartlinksProxyStreamRequest:
+          type: object
+          additionalProperties: true
+        id:
+          type: string
+        method:
+          type: string
+          enum:
+            - GET
+            - POST
+            - PUT
+            - PATCH
+            - DELETE
+        path:
+          type: string
+        body: {}
+        headers:
+          type: object
+          additionalProperties:
+            type: string
+      required:
+        - _smartlinksProxyStreamRequest
+        - id
+        - method
+        - path
+    ProxyStreamAbortMessage:
+      type: object
+      properties:
+        _smartlinksProxyStreamAbort:
+          type: object
+          additionalProperties: true
+        id:
+          type: string
+      required:
+        - _smartlinksProxyStreamAbort
+        - id
+    ProxyStreamMessage:
+      type: object
+      properties:
+        _smartlinksProxyStream:
+          type: object
+          additionalProperties: true
+        id:
+          type: string
+        phase:
+          type: string
+          enum:
+            - open
+            - event
+            - end
+            - error
+        data: {}
+        error:
+          type: string
+        status:
+          type: number
+      required:
+        - _smartlinksProxyStream
+        - id
+        - phase
     UploadStartMessage:
       type: object
       properties:

package/dist/types/iframeResponder.d.ts

@@ -68,6 +68,26 @@ export interface ProxyResponse {
     data?: any;
     error?: string;
 }
+export interface ProxyStreamRequest {
+    _smartlinksProxyStreamRequest: true;
+    id: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    body?: any;
+    headers?: Record<string, string>;
+}
+export interface ProxyStreamAbortMessage {
+    _smartlinksProxyStreamAbort: true;
+    id: string;
+}
+export interface ProxyStreamMessage {
+    _smartlinksProxyStream: true;
+    id: string;
+    phase: 'open' | 'event' | 'end' | 'error';
+    data?: any;
+    error?: string;
+    status?: number;
+}
 export interface UploadStartMessage {
     _smartlinksProxyUpload: true;
     phase: 'start';

package/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 1.8.1  |  Generated: 2026-03-14T09:21:59.178Z
+Version: 1.8.2  |  Generated: 2026-03-14T10:21:47.666Z
 
 This is a concise summary of all available API functions and types.
 
@@ -166,6 +166,14 @@ Internal helper that performs a PATCH request to `${baseURL}${path}`, injecting
   options: RequestInit) → `Promise<T>`
 Internal helper that performs a request to `${baseURL}${path}` with custom options, injecting headers for apiKey or bearerToken if present. Returns the parsed JSON as T, or throws an Error.
 
+**requestStream**(path: string,
+  options?: {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+    body?: any
+    headers?: Record<string, string>
+  }) → `Promise<AsyncIterable<T>>`
+Internal helper that performs a streaming request using the shared auth and proxy transport. The response is expected to be `text/event-stream` with JSON payloads in `data:` frames.
+
 **del**(path: string,
   extraHeaders?: Record<string, string>) → `Promise<T>`
 Internal helper that performs a DELETE request to `${baseURL}${path}`, injecting headers for apiKey or bearerToken if present. Returns the parsed JSON as T, or throws an Error.
@@ -4205,6 +4213,38 @@ interface ProxyResponse {
 }
 ```
 
+**ProxyStreamRequest** (interface)
+```typescript
+interface ProxyStreamRequest {
+  _smartlinksProxyStreamRequest: true;
+  id: string;
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  path: string;
+  body?: any;
+  headers?: Record<string, string>;
+}
+```
+
+**ProxyStreamAbortMessage** (interface)
+```typescript
+interface ProxyStreamAbortMessage {
+  _smartlinksProxyStreamAbort: true;
+  id: string;
+}
+```
+
+**ProxyStreamMessage** (interface)
+```typescript
+interface ProxyStreamMessage {
+  _smartlinksProxyStream: true;
+  id: string;
+  phase: 'open' | 'event' | 'end' | 'error';
+  data?: any;
+  error?: string;
+  status?: number;
+}
+```
+
 **UploadStartMessage** (interface)
 ```typescript
 interface UploadStartMessage {