@dbs-portal/tool-mock/dist/zustand-Db8qeUuc.js

API mocking toolkit using MSW for DBS Portal development workflows

import { i as g, s as O, l as v, a as T } from "./setup-oE-TArFC.js";
import { g as q } from "./environment-DlK8CH_m.js";
import { c as U } from "./auth-DT3h0fWG.js";
async function w(r) {
  const {
    baseURL: e,
    mockBaseURL: t = e,
    enableMocking: s = !1,
    mockConfig: n,
    mockHandlers: a = [],
    timeout: c = 3e4,
    headers: C = {},
    interceptors: u
  } = r;
  s && !g() && await O({
    config: n || {},
    handlers: a
  });
  const h = {
    async get(i, o) {
      return d("GET", i, void 0, o);
    },
    async post(i, o, l) {
      return d("POST", i, o, l);
    },
    async put(i, o, l) {
      return d("PUT", i, o, l);
    },
    async patch(i, o, l) {
      return d("PATCH", i, o, l);
    },
    async delete(i, o) {
      return d("DELETE", i, void 0, o);
    },
    isMocking() {
      return s && g();
    },
    getConfig() {
      return r;
    },
    updateConfig(i) {
      Object.assign(r, i);
    }
  };
  async function d(i, o, l, m) {
    const f = o.startsWith("http") ? o : `${h.isMocking() ? t : e}${o}`, b = {
      "Content-Type": "application/json",
      ...C,
      ...m?.headers
    };
    let k = {
      method: i,
      url: f,
      data: l,
      headers: b,
      timeout: c,
      ...m
    };
    if (u?.request)
      for (const y of u.request)
        k = y(k);
    try {
      const y = await fetch(k.url, {
        method: k.method,
        headers: k.headers,
        body: k.data ? JSON.stringify(k.data) : null,
        signal: m?.signal
      });
      if (!y.ok)
        throw new Error(`HTTP ${y.status}: ${y.statusText}`);
      let p = await y.json();
      if (u?.response)
        for (const A of u.response)
          p = A(p);
      if (p.success !== void 0) {
        if (p.success)
          return p.data;
        throw new Error(p.error?.message || "API request failed");
      }
      return p;
    } catch (y) {
      if (u?.response)
        for (const p of u.response)
          try {
            return p({ error: y });
          } catch {
          }
      throw y;
    }
  }
  return h;
}
async function $(r) {
  const e = q();
  let t;
  e.runtime.isProduction ? t = r.production : e.runtime.isTest ? t = r.testing : r.staging && process.env.NODE_ENV === "staging" ? t = r.staging : t = r.development;
  const s = {
    baseURL: "",
    enableMocking: e.shouldMock,
    ...t
  };
  return w(s);
}
function F(r) {
  const { client: e, requestTransformer: t, responseTransformer: s, errorTransformer: n } = r, a = e.request?.bind(e), c = e.get?.bind(e), C = e.post?.bind(e), u = e.put?.bind(e), h = e.patch?.bind(e), d = e.delete?.bind(e), i = (o, l) => async (...m) => {
    try {
      t && (m = t({ method: l, args: m }));
      const f = await o(...m);
      return s ? s(f) : f;
    } catch (f) {
      throw n ? n(f) : f;
    }
  };
  return a && (e.request = i(a, "request")), c && (e.get = i(c, "GET")), C && (e.post = i(C, "POST")), u && (e.put = i(u, "PUT")), h && (e.patch = i(h, "PATCH")), d && (e.delete = i(d, "DELETE")), e.isMocking = () => g(), e.getMockConfig = () => v(), e;
}
function L(r = {}) {
  return {
    /**
     * Create client for specific service
     */
    createServiceClient: async (e, t = {}) => {
      const s = {
        ...r,
        ...t,
        baseURL: t.baseURL || `${r.baseURL}/${e}`
      };
      return w(s);
    },
    /**
     * Create client with authentication
     */
    createAuthenticatedClient: async (e, t = {}) => {
      const s = {
        ...r,
        ...t,
        headers: {
          ...r.headers,
          ...t.headers,
          Authorization: `Bearer ${e}`
        }
      };
      return w(s);
    },
    /**
     * Create client with custom interceptors
     */
    createInterceptedClient: async (e, t = {}) => {
      const s = {
        ...r,
        ...t,
        interceptors: {
          ...r.interceptors,
          ...e
        }
      };
      return w(s);
    }
  };
}
async function H(r, e) {
  class t extends r {
    mockClient;
    constructor(n) {
      super(n), e?.enableMocking && this.initializeMockClient(n, e);
    }
    async initializeMockClient(n, a) {
      this.mockClient = await w({
        baseURL: n.baseURL || "",
        ...a
      });
    }
    // Override HTTP methods to use mock client when available
    async get(...n) {
      return this.mockClient?.isMocking() ? this.mockClient.get(...n) : super.get(...n);
    }
    async post(...n) {
      return this.mockClient?.isMocking() ? this.mockClient.post(...n) : super.post(...n);
    }
    async put(...n) {
      return this.mockClient?.isMocking() ? this.mockClient.put(...n) : super.put(...n);
    }
    async patch(...n) {
      return this.mockClient?.isMocking() ? this.mockClient.patch(...n) : super.patch(...n);
    }
    async delete(...n) {
      return this.mockClient?.isMocking() ? this.mockClient.delete(...n) : super.delete(...n);
    }
    isMocking() {
      return this.mockClient?.isMocking() || !1;
    }
  }
  return t;
}
class x {
  authContext;
  config;
  constructor(e = {}) {
    this.config = e, this.authContext = e.mockAuthContext || {
      isAuthenticated: !1,
      user: null,
      roles: [],
      permissions: []
    };
  }
  /**
   * Set authenticated user
   */
  setUser(e, t) {
    this.authContext = {
      isAuthenticated: !0,
      user: e,
      token: t || this.generateMockToken(e),
      roles: e.roles || [],
      permissions: e.permissions || []
    };
  }
  /**
   * Clear authentication
   */
  clearAuth() {
    this.authContext = {
      isAuthenticated: !1,
      user: null,
      // token: undefined, // Optional field
      roles: [],
      permissions: []
    };
  }
  /**
   * Get current auth context
   */
  getAuthContext() {
    return { ...this.authContext };
  }
  /**
   * Check if user is authenticated
   */
  isAuthenticated() {
    return this.authContext.isAuthenticated;
  }
  /**
   * Check if user has role
   */
  hasRole(e) {
    return this.authContext.roles?.includes(e) || !1;
  }
  /**
   * Check if user has permission
   */
  hasPermission(e) {
    return this.authContext.permissions?.includes(e) || !1;
  }
  /**
   * Get current user
   */
  getCurrentUser() {
    return this.authContext.user;
  }
  /**
   * Get current token
   */
  getCurrentToken() {
    return this.authContext.token || null;
  }
  /**
   * Validate token
   */
  async validateToken(e) {
    return this.config.tokenValidator ? this.config.tokenValidator(e) : e === this.authContext.token;
  }
  /**
   * Get user from token
   */
  async getUserFromToken(e) {
    return this.config.userProvider ? this.config.userProvider(e) : e === this.authContext.token ? this.authContext.user : null;
  }
  /**
   * Generate mock JWT token
   */
  generateMockToken(e) {
    const t = { alg: "HS256", typ: "JWT" }, s = {
      sub: e.id,
      email: e.email,
      roles: e.roles || [],
      permissions: e.permissions || [],
      iat: Math.floor(Date.now() / 1e3),
      exp: Math.floor(Date.now() / 1e3) + 3600
      // 1 hour
    }, n = btoa(JSON.stringify(t)), a = btoa(JSON.stringify(s)), c = btoa(`mock-signature-${e.id}`);
    return `${n}.${a}.${c}`;
  }
}
function S(r = {}) {
  return new x(r);
}
async function j(r = [], e = {}) {
  const t = S(e), s = U(
    e.endpoints?.login || "/api/auth",
    {
      users: r,
      enableRegistration: !0,
      enablePasswordReset: !0
    }
  );
  return T(...s), t;
}
function M(r = {}) {
  return {
    id: `user_${Date.now()}`,
    email: "user@example.com",
    password: "password",
    firstName: "Mock",
    lastName: "User",
    roles: ["user"],
    permissions: ["read"],
    isActive: !0,
    ...r
  };
}
function J(r = {}) {
  return M({
    email: "admin@example.com",
    firstName: "Admin",
    lastName: "User",
    roles: ["admin"],
    permissions: [
      "users:read",
      "users:write",
      "users:delete",
      "roles:read",
      "roles:write",
      "settings:read",
      "settings:write"
    ],
    ...r
  });
}
function W(r = {}) {
  return M({
    email: "manager@example.com",
    firstName: "Manager",
    lastName: "User",
    roles: ["manager"],
    permissions: [
      "users:read",
      "users:write",
      "roles:read"
    ],
    ...r
  });
}
function z(r, e) {
  if (!e) {
    console.warn("Core auth store not provided for integration");
    return;
  }
  const t = r.getAuthContext();
  t.isAuthenticated && t.user ? (typeof e.setUser == "function" && e.setUser(t.user), typeof e.setAuthenticated == "function" && e.setAuthenticated(!0), typeof e.setToken == "function" && e.setToken(t.token)) : typeof e.clearAuth == "function" && e.clearAuth();
}
function B(r, e = {}) {
  return r.map((t) => t);
}
function G(r) {
  return {
    useAuth: () => ({
      isAuthenticated: r.isAuthenticated(),
      user: r.getCurrentUser(),
      token: r.getCurrentToken(),
      login: async (e) => {
        const t = M({
          email: e.email
        });
        return r.setUser(t), t;
      },
      logout: () => {
        r.clearAuth();
      }
    }),
    usePermissions: () => ({
      hasPermission: (e) => r.hasPermission(e),
      hasRole: (e) => r.hasRole(e),
      permissions: r.getAuthContext().permissions || [],
      roles: r.getAuthContext().roles || []
    }),
    useCurrentUser: () => r.getCurrentUser()
  };
}
function V(r) {
  const e = S();
  if (r !== void 0) {
    const t = M(r);
    e.setUser(t);
  }
  return e;
}
class Y {
  storageKey = "mock-auth-state";
  save(e) {
    try {
      localStorage.setItem(this.storageKey, JSON.stringify(e));
    } catch (t) {
      console.warn("Failed to save mock auth state:", t);
    }
  }
  load() {
    try {
      const e = localStorage.getItem(this.storageKey);
      return e ? JSON.parse(e) : null;
    } catch (e) {
      return console.warn("Failed to load mock auth state:", e), null;
    }
  }
  clear() {
    try {
      localStorage.removeItem(this.storageKey);
    } catch (e) {
      console.warn("Failed to clear mock auth state:", e);
    }
  }
}
function Z(r = {}) {
  const e = g(), t = {
    defaultOptions: {
      queries: {
        staleTime: 300 * 1e3,
        // 5 minutes
        cacheTime: 600 * 1e3,
        // 10 minutes
        retry: 3,
        refetchOnWindowFocus: !1,
        refetchOnMount: !0,
        refetchOnReconnect: !0,
        ...r.defaultOptions?.queries
      },
      mutations: {
        retry: 1,
        ...r.defaultOptions?.mutations
      }
    }
  };
  return e && r.mockOptions && (r.mockOptions.disableRetries && (t.defaultOptions.queries.retry = !1, t.defaultOptions.mutations.retry = !1), r.mockOptions.fastStaleTime && (t.defaultOptions.queries.staleTime = 1e3), r.mockOptions.disableBackgroundRefetch && (t.defaultOptions.queries.refetchOnWindowFocus = !1, t.defaultOptions.queries.refetchOnReconnect = !1)), t;
}
class E {
  config;
  constructor(e = {}) {
    this.config = e;
  }
  /**
   * Create query key for endpoint
   */
  createKey(e, t) {
    if (this.config.queryKeyFactory)
      return this.config.queryKeyFactory(e, t);
    const s = [e];
    if (t)
      if (typeof t == "object" && t !== null) {
        const n = Object.keys(t).sort().reduce((a, c) => (a[c] = t[c], a), {});
        s.push(n);
      } else
        s.push(t);
    return s;
  }
  /**
   * Create list query key
   */
  createListKey(e, t, s) {
    const n = [e, "list"];
    return t && n.push(JSON.stringify({ filters: t })), s && n.push(JSON.stringify({ pagination: s })), n;
  }
  /**
   * Create detail query key
   */
  createDetailKey(e, t) {
    return [e, "detail", t];
  }
  /**
   * Create mutation key
   */
  createMutationKey(e, t) {
    return [e, "mutation", t];
  }
}
const X = {
  /**
   * Create mock query function
   */
  createMockQuery: (r, e, t = {}) => ({
    queryKey: r,
    queryFn: async () => {
      if (t.delay && await new Promise((s) => setTimeout(s, t.delay)), t.error)
        throw t.error;
      return e;
    }
  }),
  /**
   * Create mock infinite query
   */
  createMockInfiniteQuery: (r, e, t = {}) => ({
    queryKey: r,
    queryFn: async ({ pageParam: s = 0 }) => {
      if (t.delay && await new Promise((c) => setTimeout(c, t.delay)), t.error)
        throw t.error;
      const n = e[s];
      if (!n)
        throw new Error(`No data found for page ${s}`);
      const a = s + 1 < e.length ? s + 1 : void 0;
      return {
        data: n,
        ...a !== void 0 && { nextCursor: a }
      };
    },
    getNextPageParam: (s) => s.nextCursor
  }),
  /**
   * Create mock mutation
   */
  createMockMutation: (r, e = {}) => ({
    mutationFn: async (t) => {
      if (e.delay && await new Promise((s) => setTimeout(s, e.delay)), e.error)
        throw e.error;
      return r(t);
    }
  })
};
class P {
  queryClient;
  constructor(e) {
    this.queryClient = e;
  }
  /**
   * Invalidate queries by pattern
   */
  invalidateByPattern(e) {
    this.queryClient.invalidateQueries({
      queryKey: e
    });
  }
  /**
   * Invalidate all queries for an endpoint
   */
  invalidateEndpoint(e) {
    this.queryClient.invalidateQueries({
      queryKey: [e]
    });
  }
  /**
   * Invalidate list queries
   */
  invalidateList(e) {
    this.queryClient.invalidateQueries({
      queryKey: [e, "list"]
    });
  }
  /**
   * Invalidate detail queries
   */
  invalidateDetail(e, t) {
    const s = t ? [e, "detail", t] : [e, "detail"];
    this.queryClient.invalidateQueries({
      queryKey: s
    });
  }
  /**
   * Update query data directly
   */
  updateQueryData(e, t) {
    this.queryClient.setQueryData(e, t);
  }
  /**
   * Set query data directly
   */
  setQueryData(e, t) {
    this.queryClient.setQueryData(e, t);
  }
}
function N(r) {
  return {
    /**
     * Create mock useQuery hook
     */
    useMockQuery: (e, t, s, n) => ({
      data: s,
      isLoading: !1,
      isError: !1,
      error: null,
      refetch: () => Promise.resolve({ data: s }),
      ...n
    }),
    /**
     * Create mock useMutation hook
     */
    useMockMutation: (e, t, s) => ({
      mutate: (n) => Promise.resolve(t),
      mutateAsync: (n) => Promise.resolve(t),
      isLoading: !1,
      isError: !1,
      error: null,
      data: void 0,
      reset: () => {
      },
      ...s
    })
  };
}
function ee(r, e = {}) {
  const t = new E(e), s = new P(r), n = N();
  return {
    queryKeyFactory: t,
    invalidation: s,
    hooks: n
  };
}
function te(r) {
  typeof window < "u" && g() && window.__REACT_QUERY_DEVTOOLS__ && console.log("React Query running with MSW mock data");
}
function D(r) {
  const { name: e, initialState: t, mockData: s, actions: n = {}, persist: a = !1, storageKey: c } = r;
  let u = { ...g() && s ? { ...t, ...s } : t };
  const h = /* @__PURE__ */ new Set(), d = {
    getState: () => u,
    setState: (i) => {
      const o = typeof i == "function" ? i(u) : i;
      if (u = { ...u, ...o }, h.forEach((l) => l()), a && c)
        try {
          localStorage.setItem(c, JSON.stringify(u));
        } catch (l) {
          console.warn(`Failed to persist store ${e}:`, l);
        }
    },
    subscribe: (i) => (h.add(i), () => h.delete(i)),
    destroy: () => {
      if (h.clear(), a && c)
        try {
          localStorage.removeItem(c);
        } catch (i) {
          console.warn(`Failed to clear persisted store ${e}:`, i);
        }
    },
    // Add mock actions
    ...Object.entries(n).reduce((i, [o, l]) => (i[o] = (...m) => {
      const f = l(...m);
      return f && typeof f == "object" && d.setState(f), f;
    }, i), {})
  };
  if (a && c)
    try {
      const i = localStorage.getItem(c);
      if (i) {
        const o = JSON.parse(i);
        u = { ...u, ...o };
      }
    } catch (i) {
      console.warn(`Failed to load persisted store ${e}:`, i);
    }
  return d;
}
class R {
  stores = /* @__PURE__ */ new Map();
  // private _config: ZustandIntegrationConfig // Unused for now
  constructor(e = {}) {
  }
  /**
   * Register a mock store
   */
  registerStore(e, t) {
    const s = D({ ...t, name: e });
    return this.stores.set(e, s), s;
  }
  /**
   * Get registered store
   */
  getStore(e) {
    return this.stores.get(e);
  }
  /**
   * Update store state
   */
  updateStore(e, t) {
    const s = this.stores.get(e);
    s && s.setState(t);
  }
  /**
   * Reset store to initial state
   */
  resetStore(e) {
    const t = this.stores.get(e);
    t && t.reset && t.reset();
  }
  /**
   * Clear all stores
   */
  clearAllStores() {
    this.stores.forEach((e) => {
      e.destroy && e.destroy();
    }), this.stores.clear();
  }
  /**
   * Get all store names
   */
  getStoreNames() {
    return Array.from(this.stores.keys());
  }
  /**
   * Apply global mock state
   */
  applyGlobalMockState(e) {
    g() && Object.entries(e).forEach(([t, s]) => {
      this.updateStore(t, s);
    });
  }
}
function re(r) {
  return {
    /**
     * Use store hook
     */
    useStore: (e) => {
      const t = r.getState();
      return e ? e(t) : t;
    },
    /**
     * Use store actions
     */
    useStoreActions: () => Object.keys(r).filter((e) => typeof r[e] == "function" && e !== "getState" && e !== "setState" && e !== "subscribe").reduce((e, t) => (e[t] = r[t], e), {})
  };
}
const _ = {
  /**
   * User store mock data
   */
  userStore: {
    initialState: {
      currentUser: null,
      isAuthenticated: !1,
      loading: !1,
      error: null
    },
    mockData: {
      currentUser: {
        id: "1",
        email: "user@example.com",
        firstName: "Mock",
        lastName: "User",
        roles: ["user"]
      },
      isAuthenticated: !0
    },
    actions: {
      login: (r) => ({
        currentUser: {
          id: "1",
          email: r.email,
          firstName: "Mock",
          lastName: "User"
        },
        isAuthenticated: !0,
        loading: !1,
        error: null
      }),
      logout: () => ({
        currentUser: null,
        isAuthenticated: !1,
        loading: !1,
        error: null
      })
    }
  },
  /**
   * UI store mock data
   */
  uiStore: {
    initialState: {
      sidebarOpen: !0,
      theme: "light",
      notifications: [],
      loading: !1
    },
    mockData: {
      notifications: [
        {
          id: "1",
          type: "info",
          message: "Mock notification",
          timestamp: (/* @__PURE__ */ new Date()).toISOString()
        }
      ]
    },
    actions: {
      toggleSidebar: () => (r) => ({
        sidebarOpen: !r.sidebarOpen
      }),
      setTheme: (r) => ({ theme: r }),
      addNotification: (r) => (e) => ({
        notifications: [...e.notifications, r]
      })
    }
  },
  /**
   * Data store mock data
   */
  dataStore: {
    initialState: {
      items: [],
      loading: !1,
      error: null,
      pagination: {
        page: 1,
        pageSize: 10,
        total: 0
      }
    },
    mockData: {
      items: Array.from({ length: 5 }, (r, e) => ({
        id: `item-${e + 1}`,
        name: `Mock Item ${e + 1}`,
        description: `Description for mock item ${e + 1}`,
        createdAt: (/* @__PURE__ */ new Date()).toISOString()
      })),
      pagination: {
        page: 1,
        pageSize: 10,
        total: 5
      }
    },
    actions: {
      setItems: (r) => ({ items: r }),
      addItem: (r) => (e) => ({
        items: [...e.items, r]
      }),
      removeItem: (r) => (e) => ({
        items: e.items.filter((t) => t.id !== r)
      }),
      setLoading: (r) => ({ loading: r }),
      setError: (r) => ({ error: r })
    }
  }
};
function se(r = {}) {
  const e = new R();
  return Object.entries(r).forEach(([t, s]) => {
    e.registerStore(t, s);
  }), Object.keys(r).length === 0 && Object.entries(_).forEach(([t, s]) => {
    e.registerStore(t, { ...s, name: t });
  }), e;
}
function ne(r, e, t = {}) {
  if (!g())
    return r;
  const { override: s = !1, merge: n = !0 } = t;
  if (s)
    r.setState(e);
  else if (n) {
    const a = r.getState();
    r.setState({ ...a, ...e });
  }
  return r;
}
function ie(r) {
  typeof window < "u" && g() && (window.__MOCK_STORES__ = r, console.log("Mock stores available:", Object.keys(r)));
}
export {
  se as A,
  ne as B,
  ie as C,
  x as M,
  $ as a,
  L as b,
  w as c,
  S as d,
  J as e,
  W as f,
  z as g,
  B as h,
  H as i,
  G as j,
  V as k,
  Y as l,
  M as m,
  Z as n,
  E as o,
  X as p,
  P as q,
  N as r,
  j as s,
  ee as t,
  te as u,
  D as v,
  F as w,
  R as x,
  re as y,
  _ as z
};
//# sourceMappingURL=zustand-Db8qeUuc.js.map