accessio 1.2.0 → 1.4.0

package/src/helpers/rateLimiter.ts

@@ -21,10 +21,7 @@ export function createRateLimiter(
   }
   let active = 0;
   let destroyed = false;
-  let head = 0;
-  let tail = 0;
-  let pendingCount = 0;
-  const queue: Record<number, QueueItem> = {};
+  const queue: QueueItem[] = [];
 
   function acquire(): Promise<void> {
     if (destroyed) {
@@ -36,44 +33,34 @@ export function createRateLimiter(
       return Promise.resolve();
     }
 
-    if (pendingCount >= maxQueueSize) {
+    if (queue.length >= maxQueueSize) {
       return Promise.reject(
         new Error(`[Accessio] Rate limiter queue size exceeded maxQueueSize (${maxQueueSize})`),
       );
     }
 
     return new Promise((resolve, reject) => {
-      queue[tail++] = { resolve, reject };
-      pendingCount++;
+      queue.push({ resolve, reject });
     });
   }
 
   function release(): void {
     if (destroyed) return;
-
     if (active <= 0) return;
 
-    active--;
-
-    if (pendingCount > 0 && active < maxConcurrent) {
-      active++;
-      const next = queue[head];
-      delete queue[head];
-      head++;
-      pendingCount--;
-      next?.resolve();
+    const next = queue.shift();
+    if (next) {
+      next.resolve();
+      return;
     }
+    active--;
   }
 
   function destroy(): void {
     destroyed = true;
     const reason = new Error('[Accessio] Rate limiter destroyed — pending request cancelled');
-    while (pendingCount > 0) {
-      const next = queue[head];
-      delete queue[head];
-      head++;
-      pendingCount--;
-      next?.reject(reason);
+    while (queue.length > 0) {
+      queue.shift()!.reject(reason);
     }
   }
 
@@ -82,7 +69,7 @@ export function createRateLimiter(
     release,
     destroy,
     get pending() {
-      return pendingCount;
+      return queue.length;
     },
     get active() {
       return active;

package/src/helpers/settle.ts

@@ -9,7 +9,7 @@ export default function settle(
 ): void {
   const validateStatus = config.validateStatus;
 
-  if (!response.status || !validateStatus || validateStatus(response.status)) {
+  if (!validateStatus || validateStatus(response.status)) {
     resolve(response);
   } else {
     const error = new AccessioError(

package/src/helpers/transformData.ts

@@ -6,6 +6,7 @@ export default async function transformData(
   data: unknown,
   headers: Record<string, string | string[]>,
   config?: AccessioRequestConfig,
+  direction: 'request' | 'response' = 'request',
 ): Promise<unknown> {
   if (!transforms || !Array.isArray(transforms)) {
     return data;
@@ -20,7 +21,7 @@ export default async function transformData(
       } catch (err) {
         throw AccessioError.from(
           err instanceof Error ? err : new Error(String(err)),
-          AccessioError.ERR_BAD_REQUEST,
+          direction === 'response' ? AccessioError.ERR_BAD_RESPONSE : AccessioError.ERR_BAD_REQUEST,
           config ?? null,
           null,
           null,

package/src/interceptors/interceptorManager.ts

@@ -1,12 +1,12 @@
 import type { TransformFunction, InterceptorHandler, InterceptorOptions } from '../types';
 
 export class InterceptorManager {
-  handlers: Array<InterceptorHandler | null>;
-  private _activeCount: number;
+  private _handlers: Map<number, InterceptorHandler>;
+  private _nextId: number;
 
   constructor() {
-    this.handlers = [];
-    this._activeCount = 0;
+    this._handlers = new Map();
+    this._nextId = 0;
   }
 
   use(
@@ -14,39 +14,46 @@ export class InterceptorManager {
     rejected?: ((error: unknown) => unknown) | null,
     options: InterceptorOptions = {},
   ): number {
-    this.handlers.push({
+    const id = this._nextId++;
+    this._handlers.set(id, {
       fulfilled: fulfilled || null,
       rejected: rejected || null,
       synchronous: options.synchronous || false,
       runWhen: options.runWhen || null,
     });
-
-    this._activeCount++;
-    return this.handlers.length - 1;
+    return id;
   }
 
   eject(id: number): void {
-    if (this.handlers[id]) {
-      this.handlers[id] = null;
-      this._activeCount--;
-    }
+    this._handlers.delete(id);
   }
 
   clear(): void {
-    this.handlers = [];
-    this._activeCount = 0;
+    this._handlers.clear();
   }
 
   forEach(fn: (handler: InterceptorHandler) => void): void {
-    for (const handler of this.handlers) {
-      if (handler !== null) {
-        fn(handler);
-      }
+    for (const handler of this._handlers.values()) {
+      fn(handler);
     }
   }
 
   get size(): number {
-    return this._activeCount;
+    return this._handlers.size;
+  }
+
+  /**
+   * Snapshot view for backward-compat introspection. Slot index = interceptor ID;
+   * ejected IDs appear as `null`. Reading this builds a fresh array each time —
+   * prefer `forEach`/`size` in hot paths.
+   */
+  get handlers(): Array<InterceptorHandler | null> {
+    const max = this._nextId;
+    const out: Array<InterceptorHandler | null> = new Array(max);
+    for (let i = 0; i < max; i++) {
+      out[i] = this._handlers.get(i) ?? null;
+    }
+    return out;
   }
 }
 

package/src/types.ts

@@ -85,6 +85,7 @@ export interface AccessioRequestConfig {
   rateLimiter?: RateLimiter;
   _builtUrl?: string;
   maxContentLength?: number;
+  allowedProtocols?: string[] | null;
   dispatcher?: unknown;
   agent?: unknown;
   dedupe?: boolean;