astro-tokenkit 1.0.12 → 1.0.14

package/dist/index.js

@@ -687,46 +687,66 @@ class TokenManager {
 }
 
 // packages/astro-tokenkit/src/config.ts
-let config = {
-    runWithContext: undefined,
-    getContextStore: undefined,
-    setContextStore: undefined,
-    baseURL: "",
-};
-let tokenManager;
+const CONFIG_KEY = Symbol.for('astro-tokenkit.config');
+const MANAGER_KEY = Symbol.for('astro-tokenkit.manager');
+const globalStorage = globalThis;
+// Initialize global storage if not present
+if (!globalStorage[CONFIG_KEY]) {
+    globalStorage[CONFIG_KEY] = {
+        runWithContext: undefined,
+        getContextStore: undefined,
+        setContextStore: undefined,
+        baseURL: "",
+    };
+}
 /**
  * Set configuration
  */
 function setConfig(userConfig) {
-    const finalConfig = Object.assign(Object.assign({}, config), userConfig);
+    const currentConfig = globalStorage[CONFIG_KEY];
+    const finalConfig = Object.assign(Object.assign({}, currentConfig), userConfig);
     // Validate that getter and setter are defined together
     if ((finalConfig.getContextStore && !finalConfig.setContextStore) ||
         (!finalConfig.getContextStore && finalConfig.setContextStore)) {
         throw new Error("[TokenKit] getContextStore and setContextStore must be defined together.");
     }
-    config = finalConfig;
+    globalStorage[CONFIG_KEY] = finalConfig;
     // Re-initialize global token manager if auth changed
-    if (config.auth) {
-        tokenManager = new TokenManager(config.auth, config.baseURL);
+    if (finalConfig.auth) {
+        globalStorage[MANAGER_KEY] = new TokenManager(finalConfig.auth, finalConfig.baseURL);
+    }
+    else {
+        globalStorage[MANAGER_KEY] = undefined;
     }
 }
 /**
  * Get current configuration
  */
 function getConfig() {
-    return config;
+    return globalStorage[CONFIG_KEY];
 }
 /**
  * Get global token manager
  */
 function getTokenManager() {
-    return tokenManager;
+    return globalStorage[MANAGER_KEY];
 }
 /**
  * Set global token manager (mainly for testing)
  */
 function setTokenManager(manager) {
-    tokenManager = manager;
+    globalStorage[MANAGER_KEY] = manager;
+}
+// Handle injected configuration from Astro integration
+try {
+    // @ts-ignore
+    const injectedConfig = typeof __TOKENKIT_CONFIG__ !== 'undefined' ? __TOKENKIT_CONFIG__ : undefined;
+    if (injectedConfig) {
+        setConfig(injectedConfig);
+    }
+}
+catch (e) {
+    // Ignore errors in environments where __TOKENKIT_CONFIG__ might be restricted
 }
 
 // packages/astro-tokenkit/src/client/context.ts
@@ -809,7 +829,6 @@ function sleep(ms) {
  */
 function createMiddleware() {
     return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
         const tokenManager = getTokenManager();
         const config = getConfig();
         const runLogic = () => __awaiter(this, void 0, void 0, function* () {
@@ -826,22 +845,19 @@ function createMiddleware() {
             }
             return next();
         });
-        // If getContextStore is defined, it means the context is managed externally (e.g., by a superior ALS)
-        // We skip runWithContext to avoid nesting ALS.run() unnecessarily,
-        // UNLESS a custom runWithContext is provided.
-        if (config.getContextStore && !config.runWithContext) {
-            let storage = config.getContextStore();
-            if (storage)
-                // Update existing reference
-                storage.cookies = ctx.cookies;
-            else if (config.setContextStore)
-                config.setContextStore({ cookies: ctx.cookies });
-            else
-                console.error("[TokenKit] getContextStore returned null or undefined and no setter was found");
+        const setupAndRun = () => __awaiter(this, void 0, void 0, function* () {
+            if (config.setContextStore) {
+                config.setContextStore(ctx);
+            }
             return runLogic();
+        });
+        if (config.runWithContext) {
+            return config.runWithContext(ctx, setupAndRun);
+        }
+        if (config.setContextStore) {
+            return setupAndRun();
         }
-        const runner = (_a = config.runWithContext) !== null && _a !== void 0 ? _a : runWithContext;
-        return runner(ctx, runLogic);
+        return runWithContext(ctx, runLogic);
     });
 }
 
@@ -1211,11 +1227,23 @@ function createClient(config) {
  */
 function tokenKit(config) {
     setConfig(config);
+    // Create a serializable version of the config for the runtime
+    const serializableConfig = JSON.parse(JSON.stringify(config, (key, value) => {
+        if (typeof value === 'function')
+            return undefined;
+        return value;
+    }));
     return {
         name: 'astro-tokenkit',
         hooks: {
-            'astro:config:setup': () => {
-                // Future-proofing: could add vite aliases or other setup here
+            'astro:config:setup': ({ updateConfig }) => {
+                updateConfig({
+                    vite: {
+                        define: {
+                            '__TOKENKIT_CONFIG__': JSON.stringify(serializableConfig)
+                        }
+                    }
+                });
                 console.log('[TokenKit] Integration initialized');
             },
         },