@softwear/latestcollectioncore 1.0.162 → 1.0.163

package/dist/lcAxios.d.ts

@@ -13,11 +13,15 @@ export interface AxiosRequestConfig<D = any> {
     params?: Record<string, any>;
     headers?: Record<string, string | undefined> | any;
     timeout?: number;
-    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
     validateStatus?: (status: number) => boolean;
     transformRequest?: AxiosTransformer | AxiosTransformer[];
     transformResponse?: AxiosTransformer | AxiosTransformer[];
     withCredentials?: boolean;
+    auth?: {
+        username?: string;
+        password?: string;
+    };
     /** Axios-only; ignored — fetch handles Content-Encoding when reading the body */
     decompress?: boolean;
 }

package/dist/lcAxios.js

@@ -15,6 +15,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+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]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAxiosError = exports.lcAxios = exports.createAxiosInstance = exports.axiosRetry = exports.exponentialDelay = void 0;
 function isAxiosError(payload) {
@@ -113,6 +132,72 @@ function flattenHeaders(h, method) {
     }
     return out;
 }
+function encodeBase64(input) {
+    if (typeof Buffer !== 'undefined')
+        return Buffer.from(input, 'utf8').toString('base64');
+    if (typeof btoa !== 'undefined')
+        return btoa(input);
+    throw new Error('Base64 encoding unavailable');
+}
+function applyAuthHeader(headers, auth) {
+    if (!auth)
+        return;
+    const username = auth.username || '';
+    const password = auth.password || '';
+    headers['Authorization'] = `Basic ${encodeBase64(`${username}:${password}`)}`;
+}
+function createPipeableStream(body) {
+    return {
+        [Symbol.asyncIterator]() {
+            return __asyncGenerator(this, arguments, function* _a() {
+                if (!body)
+                    return yield __await(void 0);
+                const reader = body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = yield __await(reader.read());
+                        if (done)
+                            break;
+                        if (value)
+                            yield yield __await(value);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            });
+        },
+        pipe(destination) {
+            ;
+            (() => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                try {
+                    for (var _d = true, _e = __asyncValues(this), _f; _f = yield _e.next(), _a = _f.done, !_a;) {
+                        _c = _f.value;
+                        _d = false;
+                        try {
+                            const chunk = _c;
+                            destination.write(chunk);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (destination.end)
+                    destination.end();
+            }))();
+            return destination;
+        },
+    };
+}
 function applyTransformRequest(fns, data, headers) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!fns)
@@ -176,7 +261,11 @@ exports.axiosRetry = axiosRetry;
 const defaultValidateStatus = (status) => status >= 200 && status < 300;
 function getDefaultDefaults() {
     return {
-        headers: { common: {} },
+        headers: {
+            common: {
+                Accept: 'application/json, text/plain, */*',
+            },
+        },
         transformRequest: [
             function defaultTransformRequest(data, headers) {
                 var _a, _b;
@@ -221,6 +310,7 @@ function createAxiosInstance(initialDefaults) {
             const method = (merged.method || 'get').toUpperCase();
             const url = buildURL(merged.baseURL, merged.url, merged.params);
             const headers = Object.assign({}, flattenHeaders(merged.headers, method));
+            applyAuthHeader(headers, merged.auth);
             let data = merged.data;
             data = yield applyTransformRequest(merged.transformRequest, data, headers);
             const validateStatus = merged.validateStatus || defaultValidateStatus;
@@ -266,6 +356,9 @@ function createAxiosInstance(initialDefaults) {
             else if (rt === 'arraybuffer') {
                 parsed = yield res.arrayBuffer();
             }
+            else if (rt === 'stream') {
+                parsed = createPipeableStream(res.body || null);
+            }
             else if (rt === 'text') {
                 parsed = yield res.text();
             }
@@ -289,7 +382,9 @@ function createAxiosInstance(initialDefaults) {
                     parsed = text;
                 }
             }
-            parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders);
+            if (rt !== 'stream') {
+                parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders);
+            }
             const response = {
                 data: parsed,
                 status: res.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwear/latestcollectioncore",
-  "version": "1.0.162",
+  "version": "1.0.163",
   "description": "Core functions for LatestCollections applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lcAxios.ts

@@ -14,11 +14,15 @@ export interface AxiosRequestConfig<D = any> {
   params?: Record<string, any>
   headers?: Record<string, string | undefined> | any
   timeout?: number
-  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer'
+  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream'
   validateStatus?: (status: number) => boolean
   transformRequest?: AxiosTransformer | AxiosTransformer[]
   transformResponse?: AxiosTransformer | AxiosTransformer[]
   withCredentials?: boolean
+  auth?: {
+    username?: string
+    password?: string
+  }
   /** Axios-only; ignored — fetch handles Content-Encoding when reading the body */
   decompress?: boolean
 }
@@ -129,6 +133,44 @@ function flattenHeaders(h: any, method: string): Record<string, string> {
   return out
 }
 
+function encodeBase64(input: string): string {
+  if (typeof Buffer !== 'undefined') return Buffer.from(input, 'utf8').toString('base64')
+  if (typeof btoa !== 'undefined') return btoa(input)
+  throw new Error('Base64 encoding unavailable')
+}
+
+function applyAuthHeader(headers: Record<string, string>, auth: AxiosRequestConfig['auth']) {
+  if (!auth) return
+  const username = auth.username || ''
+  const password = auth.password || ''
+  headers['Authorization'] = `Basic ${encodeBase64(`${username}:${password}`)}`
+}
+
+function createPipeableStream(body: ReadableStream<Uint8Array> | null) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      if (!body) return
+      const reader = body.getReader()
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          if (value) yield value
+        }
+      } finally {
+        reader.releaseLock()
+      }
+    },
+    pipe(destination: { write: (chunk: Uint8Array) => any; end?: () => any }) {
+      ;(async () => {
+        for await (const chunk of this) destination.write(chunk)
+        if (destination.end) destination.end()
+      })()
+      return destination
+    },
+  }
+}
+
 async function applyTransformRequest(fns: AxiosTransformer | AxiosTransformer[] | undefined, data: any, headers: any): Promise<any> {
   if (!fns) return data
   const list = Array.isArray(fns) ? fns : [fns]
@@ -193,7 +235,11 @@ const defaultValidateStatus = (status: number) => status >= 200 && status < 300
 
 function getDefaultDefaults(): AxiosRequestConfig {
   return {
-    headers: { common: {} },
+    headers: {
+      common: {
+        Accept: 'application/json, text/plain, */*',
+      },
+    },
     transformRequest: [
       function defaultTransformRequest(data: any, headers: any) {
         if (data == null) return data
@@ -231,6 +277,7 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
     const method = (merged.method || 'get').toUpperCase()
     const url = buildURL(merged.baseURL, merged.url, merged.params)
     const headers: any = { ...flattenHeaders(merged.headers, method) }
+    applyAuthHeader(headers, merged.auth)
 
     let data = merged.data
     data = await applyTransformRequest(merged.transformRequest, data, headers)
@@ -279,6 +326,8 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
       parsed = await res.blob()
     } else if (rt === 'arraybuffer') {
       parsed = await res.arrayBuffer()
+    } else if (rt === 'stream') {
+      parsed = createPipeableStream((res.body as ReadableStream<Uint8Array> | null) || null)
     } else if (rt === 'text') {
       parsed = await res.text()
     } else if (ct.includes('application/json')) {
@@ -299,7 +348,9 @@ export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
       }
     }
 
-    parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders)
+    if (rt !== 'stream') {
+      parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders)
+    }
 
     const response: AxiosResponse = {
       data: parsed,

package/test/lcAxios.spec.ts

@@ -10,6 +10,14 @@ function jsonResponse(body: unknown, status = 200) {
   })
 }
 
+function textResponse(body: string, status = 200) {
+  return new Response(body, {
+    status,
+    statusText: status === 200 ? 'OK' : 'Error',
+    headers: { 'Content-Type': 'text/plain' },
+  })
+}
+
 describe('lcAxios', () => {
   beforeEach(() => {
     vi.stubGlobal(
@@ -34,6 +42,26 @@ describe('lcAxios', () => {
     expect(init?.body).toBeUndefined()
   })
 
+  it('GET sends axios-style default Accept header', async () => {
+    const client = axios.create()
+    await client.get('https://api.example.com/accept')
+
+    const [, init] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0]
+    const headers = init?.headers as Record<string, string>
+    expect(headers.Accept).toBe('application/json, text/plain, */*')
+  })
+
+  it('auth config sets Authorization basic header', async () => {
+    const client = axios.create()
+    await client.get('https://api.example.com/auth', {
+      auth: { username: 'aladdin', password: 'opensesame' },
+    })
+
+    const [, init] = (fetch as ReturnType<typeof vi.fn>).mock.calls[0]
+    const headers = init?.headers as Record<string, string>
+    expect(headers.Authorization).toBe('Basic YWxhZGRpbjpvcGVuc2VzYW1l')
+  })
+
   it('GET with decompress: true (axios compat) still works; option not passed to fetch', async () => {
     const client = axios.create()
     await client.get('https://api.example.com/x', { decompress: true })
@@ -131,6 +159,30 @@ describe('lcAxios', () => {
     expect(res.data).toEqual({ missing: true })
   })
 
+  it('responseType stream returns a pipeable async iterable body', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(textResponse('hello stream'))
+
+    const client = axios.create()
+    const response = await client.get('https://api.example.com/stream', {
+      responseType: 'stream',
+    })
+
+    const chunks: Uint8Array[] = []
+    await new Promise<void>((resolve) => {
+      response.data.pipe({
+        write(chunk: Uint8Array) {
+          chunks.push(chunk)
+        },
+        end() {
+          resolve()
+        },
+      })
+    })
+
+    const text = Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8')
+    expect(text).toBe('hello stream')
+  })
+
   it('axiosRetry retries when retryCondition passes and fetch then succeeds', async () => {
     vi.mocked(fetch).mockReset()
     vi.mocked(fetch).mockRejectedValueOnce(new TypeError('Failed to fetch'))