@dbs-portal/tool-mock/dist/utils-fISEXFeG.js

API mocking toolkit using MSW for DBS Portal development workflows

import { s as d } from "./setup-oE-TArFC.js";
async function w(e = {}) {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    return console.warn("Service Worker not supported in this environment"), null;
  const {
    url: t = "/mockServiceWorker.js",
    scope: n = "/",
    updateViaCache: r = "none",
    registrationOptions: a = {}
  } = e;
  try {
    const o = await navigator.serviceWorker.register(t, {
      scope: n,
      updateViaCache: r,
      ...a
    });
    return console.log("MSW Service Worker registered:", o), o;
  } catch (o) {
    return console.error("Failed to register MSW Service Worker:", o), null;
  }
}
async function S() {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    return !1;
  try {
    return (await navigator.serviceWorker.ready).active !== null;
  } catch {
    return !1;
  }
}
async function h() {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    return null;
  try {
    const e = await navigator.serviceWorker.getRegistration();
    return e ? (await e.update(), e) : null;
  } catch (e) {
    return console.error("Failed to update service worker:", e), null;
  }
}
async function k() {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    return !1;
  try {
    const e = await navigator.serviceWorker.getRegistration();
    if (e) {
      const t = await e.unregister();
      return console.log("MSW Service Worker unregistered:", t), t;
    }
    return !0;
  } catch (e) {
    return console.error("Failed to unregister service worker:", e), !1;
  }
}
async function u() {
  const e = {
    supported: typeof window < "u" && "serviceWorker" in navigator,
    registered: !1,
    active: !1,
    installing: !1,
    waiting: !1
  };
  if (!e.supported)
    return e;
  try {
    const t = await navigator.serviceWorker.getRegistration();
    t && (e.registered = !0, e.active = t.active !== null, e.installing = t.installing !== null, e.waiting = t.waiting !== null);
  } catch {
  }
  return e;
}
function W(e) {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    return () => {
    };
  const t = (n) => {
    const r = n.target?.registration;
    r && e(r);
  };
  return navigator.serviceWorker.addEventListener("controllerchange", t), () => {
    navigator.serviceWorker.removeEventListener("controllerchange", t);
  };
}
async function y(e = 1e4) {
  if (typeof window > "u" || !("serviceWorker" in navigator))
    throw new Error("Service Worker not supported");
  return new Promise((t, n) => {
    const r = setTimeout(() => {
      n(new Error("Service Worker ready timeout"));
    }, e);
    navigator.serviceWorker.ready.then((a) => {
      clearTimeout(r), t(a);
    }).catch((a) => {
      clearTimeout(r), n(a);
    });
  });
}
function g(e = {}) {
  const {
    mswVersion: t = "2.6.4",
    customCode: n = "",
    enableLogging: r = !1
  } = e;
  return `
/**
 * Mock Service Worker
 * Generated by @dbs-portal/tool-mock
 */

// Import MSW
importScripts('https://unpkg.com/msw@${t}/lib/mockServiceWorker.js');

${r ? `
// Enable logging
self.addEventListener('message', (event) => {
  console.log('MSW Service Worker message:', event.data);
});
` : ""}

// Handle MSW lifecycle events
self.addEventListener('message', async function (event) {
  const { type, payload } = event.data;

  switch (type) {
    case 'MOCK_ACTIVATE': {
      self.registration.addEventListener('activate', () => {
        event.ports[0].postMessage({ type: 'MOCK_ACTIVATED' });
      });
      break;
    }
    
    case 'MOCK_DEACTIVATE': {
      await self.registration.unregister();
      event.ports[0].postMessage({ type: 'MOCK_DEACTIVATED' });
      break;
    }
    
    case 'CLIENT_CLOSED': {
      // Handle client closed
      break;
    }
    
    default: {
      // Forward other messages to MSW
      break;
    }
  }
});

// Handle fetch events
self.addEventListener('fetch', (event) => {
  // MSW will handle this
});

// Handle install event
self.addEventListener('install', (event) => {
  ${r ? "console.log('MSW Service Worker installed');" : ""}
  self.skipWaiting();
});

// Handle activate event
self.addEventListener('activate', (event) => {
  ${r ? "console.log('MSW Service Worker activated');" : ""}
  event.waitUntil(self.clients.claim());
});

${n}
`;
}
async function M(e, t = {}) {
  const n = g(t);
  console.log(`Service worker content generated for: ${e}`), console.log(n);
}
const _ = {
  /**
   * Clear service worker cache
   */
  async clearCache() {
    if (!(typeof window > "u" || !("caches" in window)))
      try {
        const e = await caches.keys();
        await Promise.all(
          e.map((t) => caches.delete(t))
        ), console.log("Service worker cache cleared");
      } catch (e) {
        console.error("Failed to clear service worker cache:", e);
      }
  },
  /**
   * Force service worker update
   */
  async forceUpdate() {
    if (!(typeof window > "u" || !("serviceWorker" in navigator)))
      try {
        const e = await navigator.serviceWorker.getRegistration();
        e && (await e.update(), console.log("Service worker update forced"));
      } catch (e) {
        console.error("Failed to force service worker update:", e);
      }
  },
  /**
   * Get service worker info
   */
  async getInfo() {
    const e = await u();
    let t = null;
    if (e.supported)
      try {
        t = await navigator.serviceWorker.getRegistration();
      } catch {
      }
    return {
      status: e,
      registration: t ? {
        scope: t.scope,
        updateViaCache: t.updateViaCache,
        active: t.active?.state,
        installing: t.installing?.state,
        waiting: t.waiting?.state
      } : null
    };
  }
};
function E(e = {}) {
  const {
    port: t = 3e3,
    host: n = "localhost",
    https: r = !1,
    cors: a = !0,
    proxy: o = {},
    mswConfig: i = {},
    hotReload: s = {}
  } = e;
  return {
    server: {
      port: t,
      host: n,
      https: r,
      cors: a,
      proxy: o,
      // Configure middleware for MSW
      middlewareMode: !1,
      // Custom middleware
      configureServer: (c) => {
        i.enabled !== !1 && m(c, i), s.enabled !== !1 && p(c, s);
      }
    },
    // Optimizations for development
    optimizeDeps: {
      include: ["msw"],
      exclude: ["@dbs-portal/tool-mock"]
    },
    // Define environment variables
    define: {
      __MSW_ENABLED__: JSON.stringify(i.enabled !== !1),
      __MSW_LOGGING__: JSON.stringify(i.logging !== !1)
    }
  };
}
function m(e, t) {
  const { handlers: n = [], logging: r = !0, delay: a = [100, 300] } = t;
  e.middlewares.use("/mockServiceWorker.js", (o, i) => {
    if (o.method === "GET") {
      i.setHeader("Content-Type", "application/javascript"), i.setHeader("Service-Worker-Allowed", "/");
      const s = f();
      i.end(s), r && console.log("MSW: Served service worker");
    }
  }), e.middlewares.use("/api/__msw/status", (o, i) => {
    o.method === "GET" && (i.setHeader("Content-Type", "application/json"), i.end(JSON.stringify({
      enabled: !0,
      mode: "development",
      handlersCount: n.length,
      delay: a,
      timestamp: (/* @__PURE__ */ new Date()).toISOString()
    })));
  }), e.middlewares.use("/api/__msw/reload", (o, i) => {
    o.method === "POST" && (e.ws.send({
      type: "custom",
      event: "msw:reload",
      data: { timestamp: Date.now() }
    }), i.setHeader("Content-Type", "application/json"), i.end(JSON.stringify({ success: !0 })), r && console.log("MSW: Handlers reloaded"));
  }), r && console.log("MSW: Development middleware configured");
}
function p(e, t) {
  const {
    watchPaths: n = ["src/**/*mock*", "src/**/*handler*"],
    debounceDelay: r = 300
  } = t;
  let a = null;
  e.watcher.on("change", (o) => {
    n.some((s) => o.includes(s.replace("*", ""))) && (a && clearTimeout(a), a = setTimeout(() => {
      e.ws.send({
        type: "custom",
        event: "msw:file-changed",
        data: { filePath: o, timestamp: Date.now() }
      }), console.log(`MSW: Mock file changed: ${o}`);
    }, r));
  }), console.log("MSW: Hot reload middleware configured");
}
function f() {
  return `
/**
 * MSW Development Service Worker
 */

importScripts('https://unpkg.com/msw@2.6.4/lib/mockServiceWorker.js');

// Development-specific features
self.addEventListener('message', async function (event) {
  const { type, payload } = event.data;

  switch (type) {
    case 'MOCK_ACTIVATE': {
      console.log('MSW: Activating mock service worker');
      self.registration.addEventListener('activate', () => {
        event.ports[0].postMessage({ type: 'MOCK_ACTIVATED' });
      });
      break;
    }
    
    case 'MOCK_DEACTIVATE': {
      console.log('MSW: Deactivating mock service worker');
      await self.registration.unregister();
      event.ports[0].postMessage({ type: 'MOCK_DEACTIVATED' });
      break;
    }
    
    case 'MOCK_RELOAD': {
      console.log('MSW: Reloading handlers');
      // Trigger reload
      self.clients.matchAll().then(clients => {
        clients.forEach(client => {
          client.postMessage({ type: 'MSW_RELOAD' });
        });
      });
      break;
    }
    
    default: {
      // Forward to MSW
      break;
    }
  }
});

// Log requests in development
self.addEventListener('fetch', (event) => {
  if (event.request.url.includes('/api/')) {
    console.log('MSW: Intercepting request:', event.request.method, event.request.url);
  }
});

console.log('MSW: Development service worker loaded');
`;
}
const C = {
  /**
   * Create proxy configuration for API endpoints
   */
  createApiProxy: (e) => ({
    "/api": {
      target: e,
      changeOrigin: !0,
      rewrite: (t) => t.replace(/^\/api/, "")
    }
  }),
  /**
   * Create CORS configuration for development
   */
  createCorsConfig: (e = ["http://localhost:3000"]) => ({
    origin: e,
    methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
    allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
    credentials: !0
  }),
  /**
   * Create development environment variables
   */
  createDevEnvVars: (e = {}) => ({
    __DEV__: !0,
    __MSW_ENABLED__: e.mswEnabled !== !1,
    __MSW_LOGGING__: e.mswLogging !== !1,
    __API_BASE_URL__: e.apiBaseUrl || "/api"
  })
};
async function T(e = {}) {
  console.log("Starting development server with MSW support..."), e.mswConfig?.enabled !== !1 && await d({
    config: {
      enabled: !0,
      mode: "development",
      logging: e.mswConfig?.logging !== !1,
      delay: e.mswConfig?.delay || [100, 300]
    },
    handlers: e.mswConfig?.handlers || []
  }), console.log("MSW development server ready!");
}
function b() {
  return {
    "/api/__health": (e, t) => {
      t.setHeader("Content-Type", "application/json"), t.end(JSON.stringify({
        status: "healthy",
        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
        services: {
          msw: !0,
          api: !0
        }
      }));
    }
  };
}
const l = {
  /**
   * Create build configuration for MSW
   */
  createBuildConfig: (e = {}) => {
    const {
      outDir: t = "dist",
      srcDir: n = "src",
      sourcemap: r = !0,
      minify: a = !0,
      external: o = ["msw"]
    } = e;
    return {
      build: {
        outDir: t,
        sourcemap: r,
        minify: a,
        lib: {
          entry: `${n}/index.ts`,
          formats: ["es", "cjs"],
          fileName: (i) => `index.${i === "es" ? "mjs" : "js"}`
        },
        rollupOptions: {
          external: o,
          output: {
            globals: {
              msw: "msw"
            }
          }
        }
      }
    };
  },
  /**
   * Create library build configuration
   */
  createLibraryConfig: (e) => {
    const t = l.createBuildConfig(e);
    return {
      ...t,
      build: {
        ...t.build,
        lib: {
          ...t.build.lib,
          name: e.name
        }
      }
    };
  },
  /**
   * Create development build configuration
   */
  createDevConfig: (e = {}) => {
    const t = l.createBuildConfig(e);
    return {
      ...t,
      build: {
        ...t.build,
        minify: !1,
        sourcemap: !0
      }
    };
  }
}, D = {
  /**
   * Create mock module configuration
   */
  createModuleConfig: (e) => ({
    autoImport: !0,
    condition: () => !0,
    ...e
  }),
  /**
   * Generate mock module imports
   */
  generateModuleImports: (e) => {
    const t = e.filter((r) => r.autoImport && (!r.condition || r.condition())).map((r) => `import ${r.name} from '${r.path}';`).join(`
`), n = e.filter((r) => r.autoImport && (!r.condition || r.condition())).map((r) => r.name).join(", ");
    return `
${t}

export { ${n} };

export const mockModules = {
  ${e.map((r) => `${r.name}: ${r.name}`).join(`,
  `)}
};
`;
  },
  /**
   * Create conditional module loader
   */
  createConditionalLoader: (e) => `
export async function loadMockModules() {
  const modules = {};
  
  ${e.map((t) => `
  if (${t.condition?.toString() || "true"}) {
    try {
      const module = await import('${t.path}');
      modules['${t.name}'] = module;
    } catch (error) {
      console.warn('Failed to load mock module ${t.name}:', error);
    }
  }
  `).join(`
`)}
  
  return modules;
}
`
}, R = {
  /**
   * Create hot reload configuration
   */
  createHotReloadConfig: (e = {}) => ({
    enabled: !0,
    watchPatterns: ["src/**/*mock*", "src/**/*handler*"],
    debounceDelay: 300,
    strategy: "handlers-only",
    ...e
  }),
  /**
   * Generate hot reload code
   */
  generateHotReloadCode: (e) => e.enabled ? `
if (import.meta.hot) {
  import.meta.hot.accept((newModule) => {
    if (newModule) {
      console.log('MSW: Hot reloading mock handlers');
      
      // Reload strategy: ${e.strategy}
      if ('${e.strategy}' === 'handlers-only') {
        // Reload only handlers
        if (typeof window !== 'undefined' && window.__MSW_RELOAD_HANDLERS__) {
          window.__MSW_RELOAD_HANDLERS__(newModule);
        }
      } else {
        // Full reload
        window.location.reload();
      }
    }
  });
}
` : "",
  /**
   * Create file watcher patterns
   */
  createWatchPatterns: (e = []) => [...[
    "src/**/*mock*",
    "src/**/*handler*",
    "src/**/*.mock.*",
    "src/**/*.handler.*"
  ], ...e]
}, L = {
  /**
   * Create environment-specific configuration
   */
  createEnvConfig: (e) => {
    switch (e) {
      case "development":
        return {
          mswEnabled: !0,
          mswLogging: !0,
          mswDelay: [100, 300],
          hotReload: !0,
          sourcemap: !0,
          minify: !1
        };
      case "test":
        return {
          mswEnabled: !0,
          mswLogging: !1,
          mswDelay: 0,
          hotReload: !1,
          sourcemap: !0,
          minify: !1
        };
      case "production":
        return {
          mswEnabled: !1,
          mswLogging: !1,
          mswDelay: 0,
          hotReload: !1,
          sourcemap: !1,
          minify: !0
        };
      default:
        return {};
    }
  },
  /**
   * Generate environment variables
   */
  generateEnvVars: (e) => ({
    VITE_MSW_ENABLED: String(e.mswEnabled || !1),
    VITE_MSW_LOGGING: String(e.mswLogging || !1),
    VITE_MSW_DELAY: String(e.mswDelay || 0),
    VITE_HOT_RELOAD: String(e.hotReload || !1)
  })
}, A = {
  /**
   * Analyze MSW bundle impact
   */
  analyzeMSWImpact: (e) => {
    const t = e.modules?.filter(
      (r) => r.name?.includes("msw") || r.name?.includes("mock")
    ) || [], n = t.reduce(
      (r, a) => r + (a.size || 0),
      0
    );
    return {
      moduleCount: t.length,
      totalSize: n,
      modules: t,
      impact: {
        percentage: e.totalSize ? n / e.totalSize * 100 : 0,
        recommendation: n > 1e5 ? "Consider code splitting" : "Size is acceptable"
      }
    };
  },
  /**
   * Generate bundle report
   */
  generateBundleReport: (e) => `
# MSW Bundle Analysis Report

## Summary
- Mock modules: ${e.moduleCount}
- Total size: ${(e.totalSize / 1024).toFixed(2)} KB
- Bundle impact: ${e.impact.percentage.toFixed(2)}%

## Recommendation
${e.impact.recommendation}

## Modules
${e.modules.map(
    (t) => `- ${t.name}: ${(t.size / 1024).toFixed(2)} KB`
  ).join(`
`)}
`
}, O = {
  /**
   * Create performance monitoring
   */
  createPerformanceMonitor: () => {
    const e = {
      mswSetupTime: 0,
      handlerRegistrationTime: 0,
      requestInterceptionTime: 0
    };
    return {
      startTimer: (t) => {
        const n = performance.now();
        return () => {
          e[t] = performance.now() - n;
        };
      },
      getMetrics: () => ({ ...e }),
      reset: () => {
        Object.keys(e).forEach((t) => {
          e[t] = 0;
        });
      }
    };
  },
  /**
   * Generate performance report
   */
  generatePerformanceReport: (e) => `
# MSW Performance Report

## Setup Performance
- MSW Setup: ${e.mswSetupTime.toFixed(2)}ms
- Handler Registration: ${e.handlerRegistrationTime.toFixed(2)}ms
- Request Interception: ${e.requestInterceptionTime.toFixed(2)}ms

## Total Overhead
${(e.mswSetupTime + e.handlerRegistrationTime).toFixed(2)}ms
`
};
export {
  S as a,
  k as b,
  g as c,
  M as d,
  E as e,
  C as f,
  u as g,
  T as h,
  w as i,
  b as j,
  l as k,
  R as l,
  D as m,
  L as n,
  W as o,
  A as p,
  O as q,
  _ as s,
  h as u,
  y as w
};
//# sourceMappingURL=utils-fISEXFeG.js.map