snice 3.6.0 → 3.8.0

package/dist/index.d.ts

@@ -18,4 +18,6 @@ export { trackRenders } from './render-debug';
 export { debounce, throttle, once, memoize, clearDebounceTimers, clearThrottleTimers, clearMemoizeCache, resetOnce } from './method-decorators';
 export { context } from './context';
 export type { ContextOptions } from './context';
+export { ContextAwareFetcher } from './fetcher';
+export type { Fetcher, RequestMiddleware, ResponseMiddleware } from './fetcher';
 export * from './types';

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 /*!
- * snice v3.5.0
+ * snice v3.7.0
  * Imperative TypeScript framework for building vanilla web components with decorators, differential rendering, routing, and controllers. No virtual DOM, no build complexity.
  * (c) 2024
  * Released under the MIT License.
@@ -2364,7 +2364,7 @@ let contextIdCounter = 0;
  * Represents the bundled router state that can notify registered elements of changes
  */
 class Context {
-    constructor(context = {}, placards = [], currentRoute = '', routeParams = {}) {
+    constructor(context = {}, placards = [], currentRoute = '', routeParams = {}, fetcher) {
         this[_a] = new WeakMap();
         this[_b] = new Set();
         this[_c] = false;
@@ -2375,6 +2375,16 @@ class Context {
             route: currentRoute,
             params: routeParams
         };
+        // Initialize fetch with middleware support or fallback to native fetch
+        if (fetcher && typeof fetcher.create === 'function') {
+            this.fetch = fetcher.create(this);
+        }
+        else if (typeof fetch === 'function') {
+            this.fetch = fetch.bind(this);
+        }
+        else {
+            throw new Error('No fetch implementation available');
+        }
     }
     /**
      * Register an element to receive context updates
@@ -4469,7 +4479,7 @@ function Router(options) {
     let currentLayoutTimestamp = null; // Track current layout timestamp
     const context = options.context || {}; // Store context for guards
     // Create Context instance for managing router state
-    const navigationContext = new Context(context, [], '', {});
+    const navigationContext = new Context(context, [], '', {}, options.fetcher);
     function getCurrentLayoutElement(target) {
         const noCurrentLayout = !currentLayoutName || !currentLayoutTimestamp;
         if (noCurrentLayout) {
@@ -5398,5 +5408,83 @@ function resetOnce(instance, methodName) {
     }
 }
 
-export { Context, IS_CONTROLLER_INSTANCE, Router, SimpleArray, adopted, applyElementFunctionality, clearDebounceTimers, clearMemoizeCache, clearThrottleTimers, context$1 as context, context as contextProperty, controller, css, debounce, dispatch, dispose, element, getSymbol, html, layout, memoize, moved, nothing, observe, on, once, property, query, queryAll, ready, render, request, resetOnce, respond, setDisableElementReadyWarnings, styles, throttle, trackRenders, unsafeHTML, useNativeElementControllers, waitForAllCustomElements, waitForElementDefined, waitForElementReady, watch };
+/**
+ * Context-aware fetch implementation with middleware support
+ *
+ * @example
+ * ```typescript
+ * const fetcher = new ContextAwareFetcher();
+ *
+ * fetcher.use('request', function(request, next) {
+ *   const token = this.application.user?.token;
+ *   if (token) {
+ *     request.headers.set('Authorization', `Bearer ${token}`);
+ *   }
+ *   return next();
+ * });
+ *
+ * fetcher.use('response', async function(response, next) {
+ *   if (!response.ok) {
+ *     throw new Error(`HTTP ${response.status}`);
+ *   }
+ *   return next();
+ * });
+ *
+ * const router = Router({
+ *   target: '#app',
+ *   context: { user: null },
+ *   fetcher
+ * });
+ * ```
+ */
+class ContextAwareFetcher {
+    constructor() {
+        this.requestMiddlewares = [];
+        this.responseMiddlewares = [];
+    }
+    use(type, middleware) {
+        if (type === 'request') {
+            this.requestMiddlewares.push(middleware);
+        }
+        else {
+            this.responseMiddlewares.push(middleware);
+        }
+    }
+    /**
+     * Create a fetch function bound to the given Context instance
+     * @param ctx - The Context instance to bind to
+     * @returns A fetch function with middleware applied
+     */
+    create(ctx) {
+        const requestMiddlewares = this.requestMiddlewares;
+        const responseMiddlewares = this.responseMiddlewares;
+        const fetchFn = async function (input, init) {
+            const request = new Request(input, init);
+            // Request middleware chain
+            let reqIndex = 0;
+            const nextRequest = async () => {
+                if (reqIndex < requestMiddlewares.length) {
+                    const middleware = requestMiddlewares[reqIndex++];
+                    return middleware.call(this, request, nextRequest);
+                }
+                // Execute actual fetch
+                const response = await fetch(request);
+                // Response middleware chain
+                let resIndex = 0;
+                const nextResponse = async () => {
+                    if (resIndex < responseMiddlewares.length) {
+                        const middleware = responseMiddlewares[resIndex++];
+                        return middleware.call(this, response, nextResponse);
+                    }
+                    return response;
+                };
+                return nextResponse();
+            };
+            return nextRequest();
+        };
+        return fetchFn.bind(ctx);
+    }
+}
+
+export { Context, ContextAwareFetcher, IS_CONTROLLER_INSTANCE, Router, SimpleArray, adopted, applyElementFunctionality, clearDebounceTimers, clearMemoizeCache, clearThrottleTimers, context$1 as context, context as contextProperty, controller, css, debounce, dispatch, dispose, element, getSymbol, html, layout, memoize, moved, nothing, observe, on, once, property, query, queryAll, ready, render, request, resetOnce, respond, setDisableElementReadyWarnings, styles, throttle, trackRenders, unsafeHTML, useNativeElementControllers, waitForAllCustomElements, waitForElementDefined, waitForElementReady, watch };
 //# sourceMappingURL=index.esm.js.map