shelflife-react-hooks 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,1374 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthProvider: () => AuthProvider,
+  InviteProvider: () => InviteProvider,
+  ProductProvider: () => ProductProvider,
+  RunningLowProvider: () => RunningLowProvider,
+  StorageItemProvider: () => StorageItemProvider,
+  StorageMemberProvider: () => StorageMemberProvider,
+  StorageProvider: () => StorageProvider,
+  UserProvider: () => UserProvider,
+  buildAuthHeaders: () => buildAuthHeaders,
+  normalizeBaseUrl: () => normalizeBaseUrl,
+  readArrayBuffer: () => readArrayBuffer,
+  readJson: () => readJson,
+  useAuth: () => useAuth,
+  useInvites: () => useInvites,
+  useProducts: () => useProducts,
+  useRunningLow: () => useRunningLow,
+  useStorageItems: () => useStorageItems,
+  useStorageMembers: () => useStorageMembers,
+  useStorages: () => useStorages,
+  useUsers: () => useUsers
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context/AuthContext.tsx
+var import_react = require("react");
+
+// src/context/http.ts
+var normalizeBaseUrl = (baseUrl) => baseUrl.replace(/\/+$/, "");
+var buildAuthHeaders = (token) => {
+  if (!token) {
+    return {};
+  }
+  return {
+    Authorization: `Bearer ${token}`
+  };
+};
+var readJson = async (response) => {
+  const contentType = response.headers.get("content-type");
+  if (!contentType || !contentType.includes("application/json")) {
+    return null;
+  }
+  return await response.json();
+};
+var readArrayBuffer = async (response) => response.arrayBuffer();
+
+// src/context/api/requestState.ts
+var runWithRequestState = async (handlers, request) => {
+  handlers.setIsLoading(true);
+  handlers.setIsError(false);
+  handlers.setError(null);
+  try {
+    return await request();
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error("Unknown error");
+    handlers.setIsError(true);
+    handlers.setError(error);
+    throw error;
+  } finally {
+    handlers.setIsLoading(false);
+  }
+};
+
+// src/context/api/authApi.ts
+var loginRequest = async (config, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/auth/login`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    const error = await readJson(response);
+    throw new Error(error?.error ?? "Login failed");
+  }
+  const payload = await readJson(response);
+  if (!payload || !("token" in payload)) {
+    throw new Error("Login response missing token");
+  }
+  config.setToken(payload.token);
+  const meResponse = await fetch(`${normalizedBaseUrl}/api/auth/me`, {
+    headers: buildAuthHeaders(payload.token)
+  });
+  if (meResponse.ok) {
+    const mePayload = await readJson(meResponse);
+    if (mePayload) {
+      config.setUser(mePayload);
+    }
+  }
+});
+var signupRequest = async (config, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/auth/signup`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    const error = await readJson(response);
+    throw new Error(error?.error ?? "Signup failed");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Signup response missing user");
+  }
+  config.setUser(payload);
+  return payload;
+});
+var changePasswordRequest = async (config, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/auth/password/change`, {
+    method: "POST",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    const error = await readJson(response);
+    throw new Error(error?.error ?? "Change password failed");
+  }
+});
+var getMeRequest = async (config) => runWithRequestState(
+  config,
+  async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/auth/me`, {
+      headers: buildAuthHeaders(config.token)
+    });
+    if (!response.ok) {
+      config.setUser(null);
+      return null;
+    }
+    const payload = await readJson(response);
+    if (!payload) {
+      config.setUser(null);
+      return null;
+    }
+    config.setUser(payload);
+    return payload;
+  }
+);
+var logoutRequest = async (config) => runWithRequestState(
+  config,
+  async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    if (config.token) {
+      await fetch(`${normalizedBaseUrl}/api/auth/logout`, {
+        method: "POST",
+        headers: buildAuthHeaders(config.token)
+      });
+    }
+    config.setToken(null);
+    config.setUser(null);
+  }
+);
+
+// src/context/AuthContext.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AuthContext = (0, import_react.createContext)(void 0);
+var AuthProvider = ({ baseUrl, children, initialToken = null }) => {
+  const [token, setToken] = (0, import_react.useState)(initialToken);
+  const [user, setUser] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [isError, setIsError] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const getToken = (0, import_react.useCallback)(() => token, [token]);
+  const apiConfig = (0, import_react.useMemo)(() => ({
+    baseUrl,
+    token,
+    setToken,
+    setUser,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const login = (0, import_react.useCallback)((dto) => loginRequest(apiConfig, dto), [apiConfig]);
+  const signup = (0, import_react.useCallback)((dto) => signupRequest(apiConfig, dto), [apiConfig]);
+  const changePassword = (0, import_react.useCallback)(
+    (dto) => changePasswordRequest(apiConfig, dto),
+    [apiConfig]
+  );
+  const getMe = (0, import_react.useCallback)(() => getMeRequest(apiConfig), [apiConfig]);
+  const logout = (0, import_react.useCallback)(() => logoutRequest(apiConfig), [apiConfig]);
+  const value = (0, import_react.useMemo)(() => ({
+    token,
+    user,
+    isLoading,
+    isError,
+    error,
+    login,
+    signup,
+    changePassword,
+    getMe,
+    logout,
+    getToken
+  }), [
+    changePassword,
+    error,
+    getMe,
+    getToken,
+    isError,
+    isLoading,
+    login,
+    logout,
+    signup,
+    token,
+    user
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value, children });
+};
+var useAuth = () => {
+  const context = (0, import_react.useContext)(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+};
+
+// src/context/InviteContext.tsx
+var import_react2 = require("react");
+
+// src/context/api/inviteApi.ts
+var fetchInvitesRequest = async (config) => runWithRequestState(
+  config,
+  async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/invites`, {
+      headers: buildAuthHeaders(config.token)
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch invites");
+    }
+    const payload = await readJson(response);
+    if (payload) {
+      config.setInvites(payload);
+      return payload;
+    }
+    return [];
+  }
+);
+var acceptInviteRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/invites/${id}`, {
+    method: "POST",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to accept invite");
+  }
+  config.setInvites((previous) => previous.filter((invite) => invite.id !== id));
+});
+var declineInviteRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/invites/${id}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to decline invite");
+  }
+  config.setInvites((previous) => previous.filter((invite) => invite.id !== id));
+});
+
+// src/context/InviteContext.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var InviteContext = (0, import_react2.createContext)(void 0);
+var InviteProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [invites, setInvites] = (0, import_react2.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [isError, setIsError] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const apiConfig = (0, import_react2.useMemo)(() => ({
+    baseUrl,
+    token,
+    setInvites,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchInvites = (0, import_react2.useCallback)(() => fetchInvitesRequest(apiConfig), [apiConfig]);
+  const acceptInvite = (0, import_react2.useCallback)((id) => acceptInviteRequest(apiConfig, id), [apiConfig]);
+  const declineInvite = (0, import_react2.useCallback)((id) => declineInviteRequest(apiConfig, id), [apiConfig]);
+  const value = (0, import_react2.useMemo)(() => ({
+    invites,
+    isLoading,
+    isError,
+    error,
+    fetchInvites,
+    acceptInvite,
+    declineInvite
+  }), [acceptInvite, declineInvite, error, fetchInvites, isError, isLoading, invites]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(InviteContext.Provider, { value, children });
+};
+var useInvites = () => {
+  const context = (0, import_react2.useContext)(InviteContext);
+  if (!context) {
+    throw new Error("useInvites must be used within an InviteProvider");
+  }
+  return context;
+};
+
+// src/context/ProductContext.tsx
+var import_react3 = require("react");
+
+// src/context/api/productApi.ts
+var updateById = (items, updated) => {
+  const index = items.findIndex((item) => item.id === updated.id);
+  if (index === -1) {
+    return [updated, ...items];
+  }
+  const next = [...items];
+  next[index] = updated;
+  return next;
+};
+var fetchProductsRequest = async (config, query) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const params = new URLSearchParams();
+  if (query?.barcode) {
+    params.set("barcode", query.barcode);
+  }
+  if (query?.name) {
+    params.set("name", query.name);
+  }
+  if (query?.category) {
+    params.set("category", query.category);
+  }
+  const url = params.toString() ? `${normalizedBaseUrl}/api/products?${params.toString()}` : `${normalizedBaseUrl}/api/products`;
+  const response = await fetch(url, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch products");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setProducts(payload);
+    return payload;
+  }
+  return [];
+});
+var fetchProductRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/products/${id}`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (response.status === 404) {
+    config.setProduct(null);
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error("Failed to fetch product");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Product response missing data");
+  }
+  config.setProduct(payload);
+  config.setProducts((previous) => updateById(previous, payload));
+  return payload;
+});
+var createProductRequest = async (config, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/products`, {
+    method: "POST",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to create product");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Create product response missing data");
+  }
+  config.setProducts((previous) => [payload, ...previous]);
+  config.setProduct(payload);
+  return payload;
+});
+var updateProductRequest = async (config, id, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/products/${id}`, {
+    method: "PATCH",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update product");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Update product response missing data");
+  }
+  config.setProducts((previous) => updateById(previous, payload));
+  config.setProduct(payload);
+  return payload;
+});
+var deleteProductRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/products/${id}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to delete product");
+  }
+  config.setProducts((previous) => previous.filter((item) => item.id !== id));
+  config.setProduct((current) => current?.id === id ? null : current);
+});
+var getProductIconRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/products/${id}/icon`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch product icon");
+  }
+  return readArrayBuffer(response);
+});
+var uploadProductIconRequest = async (config, id, file) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const formData = new FormData();
+  formData.append("pfp", file);
+  const response = await fetch(`${normalizedBaseUrl}/api/products/${id}/icon`, {
+    method: "POST",
+    headers: buildAuthHeaders(config.token),
+    body: formData
+  });
+  if (!response.ok) {
+    throw new Error("Failed to upload product icon");
+  }
+});
+
+// src/context/ProductContext.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var ProductContext = (0, import_react3.createContext)(void 0);
+var ProductProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [products, setProducts] = (0, import_react3.useState)([]);
+  const [product, setProduct] = (0, import_react3.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  const [isError, setIsError] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const apiConfig = (0, import_react3.useMemo)(() => ({
+    baseUrl,
+    token,
+    setProducts,
+    setProduct,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchProducts = (0, import_react3.useCallback)(
+    (query) => fetchProductsRequest(apiConfig, query),
+    [apiConfig]
+  );
+  const fetchProduct = (0, import_react3.useCallback)((id) => fetchProductRequest(apiConfig, id), [apiConfig]);
+  const createProduct = (0, import_react3.useCallback)(
+    (dto) => createProductRequest(apiConfig, dto),
+    [apiConfig]
+  );
+  const updateProduct = (0, import_react3.useCallback)(
+    (id, dto) => updateProductRequest(apiConfig, id, dto),
+    [apiConfig]
+  );
+  const deleteProduct = (0, import_react3.useCallback)((id) => deleteProductRequest(apiConfig, id), [apiConfig]);
+  const getProductIcon = (0, import_react3.useCallback)((id) => getProductIconRequest(apiConfig, id), [apiConfig]);
+  const uploadProductIcon = (0, import_react3.useCallback)(
+    (id, file) => uploadProductIconRequest(apiConfig, id, file),
+    [apiConfig]
+  );
+  const value = (0, import_react3.useMemo)(() => ({
+    products,
+    product,
+    isLoading,
+    isError,
+    error,
+    fetchProducts,
+    fetchProduct,
+    createProduct,
+    updateProduct,
+    deleteProduct,
+    getProductIcon,
+    uploadProductIcon
+  }), [
+    createProduct,
+    deleteProduct,
+    error,
+    fetchProduct,
+    fetchProducts,
+    getProductIcon,
+    isError,
+    isLoading,
+    product,
+    products,
+    updateProduct,
+    uploadProductIcon
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ProductContext.Provider, { value, children });
+};
+var useProducts = () => {
+  const context = (0, import_react3.useContext)(ProductContext);
+  if (!context) {
+    throw new Error("useProducts must be used within a ProductProvider");
+  }
+  return context;
+};
+
+// src/context/RunningLowContext.tsx
+var import_react4 = require("react");
+
+// src/context/api/runningLowApi.ts
+var updateById2 = (items, updated) => {
+  const index = items.findIndex((item) => item.id === updated.id);
+  if (index === -1) {
+    return [updated, ...items];
+  }
+  const next = [...items];
+  next[index] = updated;
+  return next;
+};
+var fetchSettingsRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(
+    `${normalizedBaseUrl}/api/storages/${storageId}/runninglowsettings`,
+    {
+      headers: buildAuthHeaders(config.token)
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to fetch running low settings");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setSettings(payload);
+    return payload;
+  }
+  return [];
+});
+var createSettingRequest = async (config, storageId, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(
+    `${normalizedBaseUrl}/api/storages/${storageId}/runninglowsettings`,
+    {
+      method: "POST",
+      headers: {
+        ...buildAuthHeaders(config.token),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(dto)
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to create running low setting");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Create running low response missing data");
+  }
+  config.setSettings((previous) => [payload, ...previous]);
+  return payload;
+});
+var editSettingRequest = async (config, storageId, id, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(
+    `${normalizedBaseUrl}/api/storages/${storageId}/runninglowsettings/${id}`,
+    {
+      method: "PUT",
+      headers: {
+        ...buildAuthHeaders(config.token),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(dto)
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to edit running low setting");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Edit running low response missing data");
+  }
+  config.setSettings((previous) => updateById2(previous, payload));
+  return payload;
+});
+var deleteSettingRequest = async (config, storageId, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(
+    `${normalizedBaseUrl}/api/storages/${storageId}/runninglowsettings/${id}`,
+    {
+      method: "DELETE",
+      headers: buildAuthHeaders(config.token)
+    }
+  );
+  if (!response.ok) {
+    throw new Error("Failed to delete running low setting");
+  }
+  config.setSettings((previous) => previous.filter((item) => item.id !== id));
+});
+
+// src/context/RunningLowContext.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var RunningLowContext = (0, import_react4.createContext)(void 0);
+var RunningLowProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [settings, setSettings] = (0, import_react4.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
+  const [isError, setIsError] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const apiConfig = (0, import_react4.useMemo)(() => ({
+    baseUrl,
+    token,
+    setSettings,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchSettings = (0, import_react4.useCallback)(
+    (storageId) => fetchSettingsRequest(apiConfig, storageId),
+    [apiConfig]
+  );
+  const createSetting = (0, import_react4.useCallback)(
+    (storageId, dto) => createSettingRequest(apiConfig, storageId, dto),
+    [apiConfig]
+  );
+  const editSetting = (0, import_react4.useCallback)(
+    (storageId, id, dto) => editSettingRequest(apiConfig, storageId, id, dto),
+    [apiConfig]
+  );
+  const deleteSetting = (0, import_react4.useCallback)(
+    (storageId, id) => deleteSettingRequest(apiConfig, storageId, id),
+    [apiConfig]
+  );
+  const value = (0, import_react4.useMemo)(() => ({
+    settings,
+    isLoading,
+    isError,
+    error,
+    fetchSettings,
+    createSetting,
+    editSetting,
+    deleteSetting
+  }), [
+    createSetting,
+    deleteSetting,
+    editSetting,
+    error,
+    fetchSettings,
+    isError,
+    isLoading,
+    settings
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(RunningLowContext.Provider, { value, children });
+};
+var useRunningLow = () => {
+  const context = (0, import_react4.useContext)(RunningLowContext);
+  if (!context) {
+    throw new Error("useRunningLow must be used within a RunningLowProvider");
+  }
+  return context;
+};
+
+// src/context/StorageContext.tsx
+var import_react5 = require("react");
+
+// src/context/api/storageApi.ts
+var updateById3 = (items, updated) => {
+  const index = items.findIndex((item) => item.id === updated.id);
+  if (index === -1) {
+    return [updated, ...items];
+  }
+  const next = [...items];
+  next[index] = updated;
+  return next;
+};
+var fetchStoragesRequest = async (config) => runWithRequestState(
+  config,
+  async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages`, {
+      headers: buildAuthHeaders(config.token)
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch storages");
+    }
+    const payload = await readJson(response);
+    if (payload) {
+      config.setStorages(payload);
+      return payload;
+    }
+    return [];
+  }
+);
+var fetchStorageRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${id}`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (response.status === 404) {
+    config.setStorage(null);
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error("Failed to fetch storage");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Storage response missing data");
+  }
+  config.setStorage(payload);
+  config.setStorages((previous) => updateById3(previous, payload));
+  return payload;
+});
+var createStorageRequest = async (config, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages`, {
+    method: "POST",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to create storage");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Create storage response missing data");
+  }
+  config.setStorages((previous) => [payload, ...previous]);
+  config.setStorage(payload);
+  return payload;
+});
+var changeStorageNameRequest = async (config, id, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${id}`, {
+    method: "PATCH",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update storage");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Update storage response missing data");
+  }
+  config.setStorages((previous) => updateById3(previous, payload));
+  config.setStorage(payload);
+  return payload;
+});
+var deleteStorageRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${id}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to delete storage");
+  }
+  config.setStorages((previous) => previous.filter((item) => item.id !== id));
+  config.setStorage((current) => current?.id === id ? null : current);
+});
+
+// src/context/StorageContext.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var StorageContext = (0, import_react5.createContext)(void 0);
+var StorageProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [storages, setStorages] = (0, import_react5.useState)([]);
+  const [storage, setStorage] = (0, import_react5.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(false);
+  const [isError, setIsError] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const apiConfig = (0, import_react5.useMemo)(() => ({
+    baseUrl,
+    token,
+    setStorages,
+    setStorage,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchStorages = (0, import_react5.useCallback)(() => fetchStoragesRequest(apiConfig), [apiConfig]);
+  const fetchStorage = (0, import_react5.useCallback)((id) => fetchStorageRequest(apiConfig, id), [apiConfig]);
+  const createStorage = (0, import_react5.useCallback)(
+    (dto) => createStorageRequest(apiConfig, dto),
+    [apiConfig]
+  );
+  const changeStorageName = (0, import_react5.useCallback)(
+    (id, dto) => changeStorageNameRequest(apiConfig, id, dto),
+    [apiConfig]
+  );
+  const deleteStorage = (0, import_react5.useCallback)((id) => deleteStorageRequest(apiConfig, id), [apiConfig]);
+  const value = (0, import_react5.useMemo)(() => ({
+    storages,
+    storage,
+    isLoading,
+    isError,
+    error,
+    fetchStorages,
+    fetchStorage,
+    createStorage,
+    changeStorageName,
+    deleteStorage
+  }), [
+    changeStorageName,
+    createStorage,
+    deleteStorage,
+    error,
+    fetchStorage,
+    fetchStorages,
+    isError,
+    isLoading,
+    storage,
+    storages
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(StorageContext.Provider, { value, children });
+};
+var useStorages = () => {
+  const context = (0, import_react5.useContext)(StorageContext);
+  if (!context) {
+    throw new Error("useStorages must be used within a StorageProvider");
+  }
+  return context;
+};
+
+// src/context/StorageItemContext.tsx
+var import_react6 = require("react");
+
+// src/context/api/storageItemApi.ts
+var updateById4 = (items, updated) => {
+  const index = items.findIndex((item) => item.id === updated.id);
+  if (index === -1) {
+    return [updated, ...items];
+  }
+  const next = [...items];
+  next[index] = updated;
+  return next;
+};
+var fetchItemsRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/items`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch storage items");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setItems(payload);
+    return payload;
+  }
+  return [];
+});
+var addItemRequest = async (config, storageId, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/items`, {
+    method: "POST",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to add storage item");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Add item response missing data");
+  }
+  config.setItems((previous) => [payload, ...previous]);
+  return payload;
+});
+var editItemRequest = async (config, storageId, itemId, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/items/${itemId}`, {
+    method: "PATCH",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to edit storage item");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Edit item response missing data");
+  }
+  config.setItems((previous) => updateById4(previous, payload));
+  return payload;
+});
+var deleteItemRequest = async (config, storageId, itemId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/items/${itemId}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to delete storage item");
+  }
+  config.setItems((previous) => previous.filter((item) => item.id !== itemId));
+});
+var fetchExpiredRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/expired`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch expired items");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setExpiredItems(payload);
+    return payload;
+  }
+  return [];
+});
+var fetchAboutToExpireRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/abouttoexpire`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch items about to expire");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setAboutToExpireItems(payload);
+    return payload;
+  }
+  return [];
+});
+var fetchRunningLowRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/runninglow`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch running low items");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setRunningLow(payload);
+    return payload;
+  }
+  return [];
+});
+
+// src/context/StorageItemContext.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var StorageItemContext = (0, import_react6.createContext)(void 0);
+var StorageItemProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [items, setItems] = (0, import_react6.useState)([]);
+  const [expiredItems, setExpiredItems] = (0, import_react6.useState)([]);
+  const [aboutToExpireItems, setAboutToExpireItems] = (0, import_react6.useState)([]);
+  const [runningLow, setRunningLow] = (0, import_react6.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(false);
+  const [isError, setIsError] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const apiConfig = (0, import_react6.useMemo)(() => ({
+    baseUrl,
+    token,
+    setItems,
+    setExpiredItems,
+    setAboutToExpireItems,
+    setRunningLow,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchItems = (0, import_react6.useCallback)((storageId) => fetchItemsRequest(apiConfig, storageId), [apiConfig]);
+  const addItem = (0, import_react6.useCallback)(
+    (storageId, dto) => addItemRequest(apiConfig, storageId, dto),
+    [apiConfig]
+  );
+  const editItem = (0, import_react6.useCallback)(
+    (storageId, itemId, dto) => editItemRequest(apiConfig, storageId, itemId, dto),
+    [apiConfig]
+  );
+  const deleteItem = (0, import_react6.useCallback)(
+    (storageId, itemId) => deleteItemRequest(apiConfig, storageId, itemId),
+    [apiConfig]
+  );
+  const fetchExpired = (0, import_react6.useCallback)(
+    (storageId) => fetchExpiredRequest(apiConfig, storageId),
+    [apiConfig]
+  );
+  const fetchAboutToExpire = (0, import_react6.useCallback)(
+    (storageId) => fetchAboutToExpireRequest(apiConfig, storageId),
+    [apiConfig]
+  );
+  const fetchRunningLow = (0, import_react6.useCallback)(
+    (storageId) => fetchRunningLowRequest(apiConfig, storageId),
+    [apiConfig]
+  );
+  const value = (0, import_react6.useMemo)(() => ({
+    items,
+    expiredItems,
+    aboutToExpireItems,
+    runningLow,
+    isLoading,
+    isError,
+    error,
+    fetchItems,
+    addItem,
+    editItem,
+    deleteItem,
+    fetchExpired,
+    fetchAboutToExpire,
+    fetchRunningLow
+  }), [
+    aboutToExpireItems,
+    addItem,
+    deleteItem,
+    editItem,
+    error,
+    expiredItems,
+    fetchAboutToExpire,
+    fetchExpired,
+    fetchItems,
+    fetchRunningLow,
+    isError,
+    isLoading,
+    items,
+    runningLow
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(StorageItemContext.Provider, { value, children });
+};
+var useStorageItems = () => {
+  const context = (0, import_react6.useContext)(StorageItemContext);
+  if (!context) {
+    throw new Error("useStorageItems must be used within a StorageItemProvider");
+  }
+  return context;
+};
+
+// src/context/StorageMemberContext.tsx
+var import_react7 = require("react");
+
+// src/context/api/storageMemberApi.ts
+var fetchMembersRequest = async (config, storageId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/members`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch storage members");
+  }
+  const payload = await readJson(response);
+  if (payload) {
+    config.setMembers(payload);
+    return payload;
+  }
+  return [];
+});
+var inviteMemberRequest = async (config, storageId, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/members`, {
+    method: "POST",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to invite member");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Invite member response missing data");
+  }
+  config.setMembers((previous) => [payload, ...previous]);
+  return payload;
+});
+var removeMemberRequest = async (config, storageId, userId) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/members/${userId}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to remove member");
+  }
+  config.setMembers((previous) => previous.filter((member) => member.user.id !== userId));
+});
+
+// src/context/StorageMemberContext.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var StorageMemberContext = (0, import_react7.createContext)(void 0);
+var StorageMemberProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [members, setMembers] = (0, import_react7.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
+  const [isError, setIsError] = (0, import_react7.useState)(false);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const apiConfig = (0, import_react7.useMemo)(() => ({
+    baseUrl,
+    token,
+    setMembers,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchMembers = (0, import_react7.useCallback)(
+    (storageId) => fetchMembersRequest(apiConfig, storageId),
+    [apiConfig]
+  );
+  const inviteMember = (0, import_react7.useCallback)(
+    (storageId, dto) => inviteMemberRequest(apiConfig, storageId, dto),
+    [apiConfig]
+  );
+  const removeMember = (0, import_react7.useCallback)(
+    (storageId, userId) => removeMemberRequest(apiConfig, storageId, userId),
+    [apiConfig]
+  );
+  const value = (0, import_react7.useMemo)(() => ({
+    members,
+    isLoading,
+    isError,
+    error,
+    fetchMembers,
+    inviteMember,
+    removeMember
+  }), [error, fetchMembers, inviteMember, isError, isLoading, members, removeMember]);
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(StorageMemberContext.Provider, { value, children });
+};
+var useStorageMembers = () => {
+  const context = (0, import_react7.useContext)(StorageMemberContext);
+  if (!context) {
+    throw new Error("useStorageMembers must be used within a StorageMemberProvider");
+  }
+  return context;
+};
+
+// src/context/UserContext.tsx
+var import_react8 = require("react");
+
+// src/context/api/userApi.ts
+var updateById5 = (items, updated) => {
+  const index = items.findIndex((item) => item.id === updated.id);
+  if (index === -1) {
+    return [updated, ...items];
+  }
+  const next = [...items];
+  next[index] = updated;
+  return next;
+};
+var fetchUsersRequest = async (config) => runWithRequestState(
+  config,
+  async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/users`, {
+      headers: buildAuthHeaders(config.token)
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch users");
+    }
+    const payload = await readJson(response);
+    if (payload) {
+      config.setUsers(payload);
+      return payload;
+    }
+    return [];
+  }
+);
+var fetchUserRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/users/${id}`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (response.status === 404) {
+    config.setUser(null);
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error("Failed to fetch user");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("User response missing data");
+  }
+  config.setUser(payload);
+  config.setUsers((previous) => updateById5(previous, payload));
+  return payload;
+});
+var updateUserRequest = async (config, id, dto) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/users/${id}`, {
+    method: "PATCH",
+    headers: {
+      ...buildAuthHeaders(config.token),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(dto)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update user");
+  }
+  const payload = await readJson(response);
+  if (!payload) {
+    throw new Error("Update user response missing data");
+  }
+  config.setUsers((previous) => updateById5(previous, payload));
+  config.setUser(payload);
+  return payload;
+});
+var deleteUserRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/users/${id}`, {
+    method: "DELETE",
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to delete user");
+  }
+  config.setUsers((previous) => previous.filter((item) => item.id !== id));
+  config.setUser((current) => current?.id === id ? null : current);
+});
+var getUserPfpRequest = async (config, id) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const response = await fetch(`${normalizedBaseUrl}/api/users/${id}/pfp`, {
+    headers: buildAuthHeaders(config.token)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch user pfp");
+  }
+  return readArrayBuffer(response);
+});
+var uploadUserPfpRequest = async (config, id, file) => runWithRequestState(config, async () => {
+  const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+  const formData = new FormData();
+  formData.append("pfp", file);
+  const response = await fetch(`${normalizedBaseUrl}/api/users/${id}/pfp`, {
+    method: "POST",
+    headers: buildAuthHeaders(config.token),
+    body: formData
+  });
+  if (!response.ok) {
+    throw new Error("Failed to upload user pfp");
+  }
+});
+
+// src/context/UserContext.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var UserContext = (0, import_react8.createContext)(void 0);
+var UserProvider = ({ baseUrl, children }) => {
+  const { token } = useAuth();
+  const [users, setUsers] = (0, import_react8.useState)([]);
+  const [user, setUser] = (0, import_react8.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
+  const [isError, setIsError] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const apiConfig = (0, import_react8.useMemo)(() => ({
+    baseUrl,
+    token,
+    setUsers,
+    setUser,
+    setIsLoading,
+    setIsError,
+    setError
+  }), [baseUrl, token]);
+  const fetchUsers = (0, import_react8.useCallback)(() => fetchUsersRequest(apiConfig), [apiConfig]);
+  const fetchUser = (0, import_react8.useCallback)((id) => fetchUserRequest(apiConfig, id), [apiConfig]);
+  const updateUser = (0, import_react8.useCallback)(
+    (id, dto) => updateUserRequest(apiConfig, id, dto),
+    [apiConfig]
+  );
+  const deleteUser = (0, import_react8.useCallback)((id) => deleteUserRequest(apiConfig, id), [apiConfig]);
+  const getUserPfp = (0, import_react8.useCallback)((id) => getUserPfpRequest(apiConfig, id), [apiConfig]);
+  const uploadUserPfp = (0, import_react8.useCallback)(
+    (id, file) => uploadUserPfpRequest(apiConfig, id, file),
+    [apiConfig]
+  );
+  const value = (0, import_react8.useMemo)(() => ({
+    users,
+    user,
+    isLoading,
+    isError,
+    error,
+    fetchUsers,
+    fetchUser,
+    updateUser,
+    deleteUser,
+    getUserPfp,
+    uploadUserPfp
+  }), [
+    deleteUser,
+    error,
+    fetchUser,
+    fetchUsers,
+    getUserPfp,
+    isError,
+    isLoading,
+    updateUser,
+    uploadUserPfp,
+    user,
+    users
+  ]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(UserContext.Provider, { value, children });
+};
+var useUsers = () => {
+  const context = (0, import_react8.useContext)(UserContext);
+  if (!context) {
+    throw new Error("useUsers must be used within a UserProvider");
+  }
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthProvider,
+  InviteProvider,
+  ProductProvider,
+  RunningLowProvider,
+  StorageItemProvider,
+  StorageMemberProvider,
+  StorageProvider,
+  UserProvider,
+  buildAuthHeaders,
+  normalizeBaseUrl,
+  readArrayBuffer,
+  readJson,
+  useAuth,
+  useInvites,
+  useProducts,
+  useRunningLow,
+  useStorageItems,
+  useStorageMembers,
+  useStorages,
+  useUsers
+});
+//# sourceMappingURL=index.cjs.js.map