feeef 0.5.38-dev.2 → 0.5.38-dev.4

package/build/index.js

@@ -190,9 +190,27 @@ var StoreRepository = class extends ModelRepository {
 // src/feeef/repositories/users.ts
 var UserRepository = class extends ModelRepository {
   /**
-   * Represents the authentication response.
+   * Represents the current authentication response.
+   * Set automatically after signin, signup, or signinWithToken.
    */
-  auth = null;
+  _auth = null;
+  /**
+   * Gets the current authentication response.
+   */
+  get auth() {
+    return this._auth;
+  }
+  /**
+   * Sets the authentication response and updates the Authorization header.
+   */
+  set auth(value) {
+    this._auth = value;
+    if (value?.token?.token) {
+      this.client.defaults.headers.common["Authorization"] = `Bearer ${value.token.token}`;
+    } else {
+      delete this.client.defaults.headers.common["Authorization"];
+    }
+  }
   /**
    * Constructs a new UserRepository instance.
    * @param client - The AxiosInstance used for making HTTP requests.
@@ -202,43 +220,264 @@ var UserRepository = class extends ModelRepository {
   }
   /**
    * Signs in a user with the provided credentials.
-   * @param credentials - The user credentials.
+   * @param credentials - The user credentials (email, password, optional fcmToken).
    * @returns A promise that resolves to the authentication response.
    */
   async signin(credentials) {
-    const output = credentials;
-    const res = await this.client.post(`/${this.resource}/auth/signin`, output);
+    const res = await this.client.post(`/${this.resource}/auth/signin`, credentials);
     this.auth = res.data;
-    return res.data;
+    return this.auth;
   }
   /**
    * Signs up a new user with the provided credentials.
-   * @param credentials - The user credentials.
+   * @param credentials - The user signup credentials.
    * @returns A promise that resolves to the authentication response.
    */
   async signup(credentials) {
-    const output = credentials;
-    const res = await this.client.post(`/${this.resource}/auth/signup`, output);
+    const res = await this.client.post(`/${this.resource}/auth/signup`, credentials);
     this.auth = res.data;
-    return res.data;
+    return this.auth;
+  }
+  /**
+   * Signs in a user with an existing token.
+   * Useful for restoring authentication state from localStorage.
+   * @param token - The authentication token.
+   * @param fcmToken - Optional FCM token for push notifications.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async signinWithToken(token, fcmToken) {
+    this.client.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    const res = await this.client.get(`/${this.resource}/auth`);
+    if (fcmToken) {
+      try {
+        await this.client.post(`/${this.resource}/auth/fcm-token`, { fcmToken });
+      } catch (e) {
+        console.warn("Failed to update FCM token:", e);
+      }
+    }
+    this.auth = {
+      user: res.data.user,
+      token: { ...res.data.token, token }
+    };
+    return this.auth;
   }
   /**
    * Signs out the currently authenticated user.
+   * Deletes the token on the server and clears local auth state.
    * @returns A promise that resolves when the user is signed out.
    */
   async signout() {
+    if (this.auth) {
+      try {
+        await this.client.post(`/${this.resource}/auth/signout`);
+      } catch (e) {
+        console.warn("Signout request failed:", e);
+      }
+    }
     this.auth = null;
   }
   /**
-   * Updates the authenticated user's data.
+   * Gets the currently authenticated user.
+   * @returns A promise that resolves to the authentication response with current user.
+   */
+  async me() {
+    const res = await this.client.get(`/${this.resource}/auth`);
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Updates the authenticated user's profile.
    * @param data - The updated user data.
    * @returns A promise that resolves to the updated user entity.
    */
   async updateMe(data) {
-    const output = data;
-    const res = await this.client.put(`/${this.resource}/auth`, output);
+    const res = await this.client.put(`/${this.resource}/auth`, data);
+    if (this.auth) {
+      this.auth = {
+        ...this.auth,
+        user: res.data
+      };
+    }
+    return res.data;
+  }
+  /**
+   * Sends a password reset email to the user.
+   * @param email - The user's email address.
+   * @returns A promise that resolves when the email is sent.
+   */
+  async sendResetPasswordEmail(email) {
+    await this.client.post(`/${this.resource}/auth/reset-password`, null, {
+      params: { email }
+    });
+  }
+  /**
+   * Resets the password using a token from the reset email.
+   * @param uid - The user ID.
+   * @param token - The reset token from the email.
+   * @returns A promise that resolves when the password is reset.
+   */
+  async resetPasswordWithToken(uid, token) {
+    await this.client.get(`/${this.resource}/auth/reset-password`, {
+      params: { uid, token }
+    });
+  }
+  /**
+   * Gets all access tokens for the authenticated user.
+   * @returns A promise that resolves to an array of access tokens.
+   */
+  async tokens() {
+    const res = await this.client.get(`/${this.resource}/auth/tokens`);
+    return res.data;
+  }
+  /**
+   * Signs in with Google OAuth.
+   * @param options - The OAuth code and optional FCM token.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async signinWithGoogle(options) {
+    const res = await this.client.post("/social/google/callback", {
+      code: options.code,
+      fcmToken: options.fcmToken
+    });
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Signs in with GitHub OAuth.
+   * @param options - The OAuth code and optional FCM token.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async signinWithGitHub(options) {
+    const res = await this.client.post("/social/github/callback", {
+      code: options.code,
+      fcmToken: options.fcmToken
+    });
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Signs in with Apple OAuth.
+   * @param options - The OAuth code and optional FCM token.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async signinWithApple(options) {
+    const res = await this.client.post("/social/apple/callback", {
+      code: options.code,
+      fcmToken: options.fcmToken
+    });
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Links a social account to the current user.
+   * @param options - The provider and OAuth code.
+   * @returns A promise that resolves to the updated user entity.
+   */
+  async linkSocialAccount(options) {
+    const res = await this.client.post(`/social/${options.provider}/link/callback`, {
+      code: options.code
+    });
+    if (this.auth && this.auth.user.id === res.data.user.id) {
+      this.auth = {
+        ...this.auth,
+        user: res.data.user
+      };
+    }
+    return res.data.user;
+  }
+  /**
+   * Unlinks a social account from the current user.
+   * @param provider - The social provider to unlink.
+   * @returns A promise that resolves to the updated user entity.
+   */
+  async unlinkSocialAccount(provider) {
+    const res = await this.client.post("/social/unlink", { provider });
+    if (this.auth && this.auth.user.id === res.data.user.id) {
+      this.auth = {
+        ...this.auth,
+        user: res.data.user
+      };
+    }
+    return res.data.user;
+  }
+  /**
+   * Transfers money from the authenticated user to another user.
+   * @param options - Transfer options including recipient and amount.
+   * @returns A promise that resolves to the transfer response with updated users.
+   */
+  async transferMoney(options) {
+    const res = await this.client.post(`/${this.resource}/auth/transfer`, options);
+    if (this.auth && this.auth.user.id === res.data.sender.id) {
+      this.auth = {
+        ...this.auth,
+        user: res.data.sender
+      };
+    }
+    return res.data;
+  }
+  /**
+   * Starts passkey registration.
+   * @param options - Optional device name for the passkey.
+   * @returns A promise that resolves to the registration challenge data.
+   */
+  async startPasskeyRegistration(options) {
+    const res = await this.client.post("/passkeys/register/start", {
+      deviceName: options?.deviceName
+    });
     return res.data;
   }
+  /**
+   * Finishes passkey registration.
+   * @param options - The registration response from the authenticator.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async finishPasskeyRegistration(options) {
+    const res = await this.client.post("/passkeys/register/finish", {
+      response: options.registrationResponse,
+      deviceName: options.deviceName
+    });
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Starts passkey authentication.
+   * @param options - Optional email to identify the user.
+   * @returns A promise that resolves to the authentication challenge data.
+   */
+  async startPasskeyAuthentication(options) {
+    const res = await this.client.post("/passkeys/authenticate/start", {
+      email: options?.email
+    });
+    return res.data;
+  }
+  /**
+   * Finishes passkey authentication.
+   * @param options - The authentication response from the authenticator.
+   * @returns A promise that resolves to the authentication response.
+   */
+  async finishPasskeyAuthentication(options) {
+    const res = await this.client.post("/passkeys/authenticate/finish", {
+      response: options.authenticationResponse
+    });
+    this.auth = res.data;
+    return this.auth;
+  }
+  /**
+   * Lists all passkeys for the authenticated user.
+   * @returns A promise that resolves to an array of passkeys.
+   */
+  async listPasskeys() {
+    const res = await this.client.get("/passkeys");
+    return res.data.passkeys || [];
+  }
+  /**
+   * Deletes a passkey.
+   * @param passkeyId - The ID of the passkey to delete.
+   * @returns A promise that resolves when the passkey is deleted.
+   */
+  async deletePasskey(passkeyId) {
+    await this.client.delete(`/passkeys/${passkeyId}`);
+  }
 };
 
 // src/feeef/repositories/deposits.ts
@@ -304,6 +543,17 @@ var DepositRepository = class extends ModelRepository {
   }
 };
 
+// src/feeef/repositories/transfers.ts
+var TransferRepository = class extends ModelRepository {
+  /**
+   * Constructs a new TransferRepository instance
+   * @param client - The AxiosInstance used for making HTTP requests
+   */
+  constructor(client) {
+    super("transfers", client);
+  }
+};
+
 // src/feeef/repositories/categories.ts
 var CategoryRepository = class extends ModelRepository {
   /**
@@ -315,6 +565,297 @@ var CategoryRepository = class extends ModelRepository {
   }
 };
 
+// src/feeef/repositories/countries.ts
+var CountryRepository = class extends ModelRepository {
+  /**
+   * Constructs a new CountryRepository instance.
+   * @param client The AxiosInstance used for making HTTP requests.
+   */
+  constructor(client) {
+    super("countries", client);
+  }
+  /**
+   * Finds a country by its code (ID is the country code).
+   * @param code - The country code (ISO 3166-1 alpha-2).
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the found Country entity.
+   */
+  async findByCode(code, params) {
+    return this.find({ id: code.toUpperCase(), params });
+  }
+};
+
+// src/feeef/repositories/states.ts
+var StateRepository = class extends ModelRepository {
+  /**
+   * Constructs a new StateRepository instance.
+   * @param client The AxiosInstance used for making HTTP requests.
+   */
+  constructor(client) {
+    super("states", client);
+  }
+  /**
+   * Lists states, optionally filtered by country code.
+   * @param options - The options for listing states, including countryCode filter.
+   * @returns A Promise that resolves to a list of State entities.
+   */
+  async list(options) {
+    const { countryCode, ...listOptions } = options || {};
+    const params = {
+      ...listOptions.params,
+      ...countryCode && { country_code: countryCode }
+    };
+    return super.list({ ...listOptions, params });
+  }
+  /**
+   * Lists states for a specific country (nested route).
+   * @param countryCode - The country code.
+   * @param options - Optional list options.
+   * @returns A Promise that resolves to a list of State entities.
+   */
+  async listByCountry(countryCode, options) {
+    const res = await this.client.get(`/countries/${countryCode}/states`, {
+      params: {
+        page: options?.page,
+        offset: options?.offset,
+        limit: options?.limit,
+        ...options?.params
+      }
+    });
+    if (Array.isArray(res.data)) {
+      return { data: res.data };
+    } else {
+      return {
+        data: res.data.data,
+        total: res.data.meta.total,
+        page: res.data.meta.currentPage,
+        limit: res.data.meta.perPage
+      };
+    }
+  }
+  /**
+   * Finds a state by country code and state code.
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the found State entity.
+   */
+  async findByCode(countryCode, stateCode, params) {
+    const res = await this.client.get(`/countries/${countryCode}/states/${stateCode}`, { params });
+    return res.data;
+  }
+  /**
+   * Creates a new state (nested under country).
+   * @param countryCode - The country code.
+   * @param data - The state data.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the created State entity.
+   */
+  async createByCountry(countryCode, data, params) {
+    const res = await this.client.post(`/countries/${countryCode}/states`, data, { params });
+    return res.data;
+  }
+  /**
+   * Updates a state (nested under country).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param data - The update data.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the updated State entity.
+   */
+  async updateByCountry(countryCode, stateCode, data, params) {
+    const res = await this.client.put(`/countries/${countryCode}/states/${stateCode}`, data, {
+      params
+    });
+    return res.data;
+  }
+  /**
+   * Deletes a state (nested under country).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves when the state is deleted.
+   */
+  async deleteByCountry(countryCode, stateCode, params) {
+    await this.client.delete(`/countries/${countryCode}/states/${stateCode}`, { params });
+  }
+};
+
+// src/feeef/repositories/cities.ts
+var CityRepository = class extends ModelRepository {
+  /**
+   * Constructs a new CityRepository instance.
+   * @param client The AxiosInstance used for making HTTP requests.
+   */
+  constructor(client) {
+    super("cities", client);
+  }
+  /**
+   * Lists cities, optionally filtered by country code and/or state code.
+   * @param options - The options for listing cities, including filters.
+   * @returns A Promise that resolves to a list of City entities.
+   */
+  async list(options) {
+    const { countryCode, stateCode, ...listOptions } = options || {};
+    const params = {
+      ...listOptions.params,
+      ...countryCode && { country_code: countryCode },
+      ...stateCode && { state_code: stateCode }
+    };
+    return super.list({ ...listOptions, params });
+  }
+  /**
+   * Lists cities for a specific country and state (nested route).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param options - Optional list options.
+   * @returns A Promise that resolves to a list of City entities.
+   */
+  async listByState(countryCode, stateCode, options) {
+    const res = await this.client.get(`/countries/${countryCode}/states/${stateCode}/cities`, {
+      params: {
+        page: options?.page,
+        offset: options?.offset,
+        limit: options?.limit,
+        ...options?.params
+      }
+    });
+    if (Array.isArray(res.data)) {
+      return { data: res.data };
+    } else {
+      return {
+        data: res.data.data,
+        total: res.data.meta.total,
+        page: res.data.meta.currentPage,
+        limit: res.data.meta.perPage
+      };
+    }
+  }
+  /**
+   * Finds a city by country code, state code, and city name.
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param cityName - The city name.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the found City entity.
+   */
+  async findByName(countryCode, stateCode, cityName, params) {
+    const res = await this.client.get(
+      `/countries/${countryCode}/states/${stateCode}/cities/${cityName}`,
+      { params }
+    );
+    return res.data;
+  }
+  /**
+   * Creates a new city (nested under country/state).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param data - The city data.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the created City entity.
+   */
+  async createByState(countryCode, stateCode, data, params) {
+    const res = await this.client.post(
+      `/countries/${countryCode}/states/${stateCode}/cities`,
+      data,
+      { params }
+    );
+    return res.data;
+  }
+  /**
+   * Updates a city (nested under country/state).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param cityName - The city name.
+   * @param data - The update data.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the updated City entity.
+   */
+  async updateByState(countryCode, stateCode, cityName, data, params) {
+    const res = await this.client.put(
+      `/countries/${countryCode}/states/${stateCode}/cities/${cityName}`,
+      data,
+      { params }
+    );
+    return res.data;
+  }
+  /**
+   * Deletes a city (nested under country/state).
+   * @param countryCode - The country code.
+   * @param stateCode - The state code.
+   * @param cityName - The city name.
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves when the city is deleted.
+   */
+  async deleteByState(countryCode, stateCode, cityName, params) {
+    await this.client.delete(`/countries/${countryCode}/states/${stateCode}/cities/${cityName}`, {
+      params
+    });
+  }
+  /**
+   * Searches cities by name (autocomplete).
+   * @param query - The search query.
+   * @param options - Optional filters (countryCode, stateCode).
+   * @returns A Promise that resolves to a list of matching City entities.
+   */
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.countryCode) params.country_code = options.countryCode;
+    if (options?.stateCode) params.state_code = options.stateCode;
+    const res = await this.client.get("/cities/search", { params });
+    return res.data;
+  }
+};
+
+// src/feeef/repositories/currencies.ts
+var CurrencyRepository = class extends ModelRepository {
+  /**
+   * Constructs a new CurrencyRepository instance.
+   * @param client The AxiosInstance used for making HTTP requests.
+   */
+  constructor(client) {
+    super("currencies", client);
+  }
+  /**
+   * Finds a currency by its code (ID is the currency code).
+   * @param code - The currency code (ISO 4217, e.g., USD, EUR).
+   * @param params - Optional query parameters.
+   * @returns A Promise that resolves to the found Currency entity.
+   */
+  async findByCode(code, params) {
+    return this.find({ id: code.toUpperCase(), params });
+  }
+};
+
+// src/feeef/repositories/shipping_prices.ts
+var ShippingPriceRepository = class extends ModelRepository {
+  /**
+   * Constructs a new ShippingPriceRepository instance.
+   * @param client The AxiosInstance used for making HTTP requests.
+   */
+  constructor(client) {
+    super("shipping_prices", client);
+  }
+  /**
+   * Creates a new ShippingPrice entity.
+   * @param options The options for creating the ShippingPrice entity.
+   * @returns A Promise that resolves to the created ShippingPrice entity.
+   */
+  async create(options) {
+    const output = options.data;
+    return super.create({ ...options, data: output });
+  }
+  /**
+   * Finds a ShippingPrice by store ID.
+   * @param storeId The store ID to search for.
+   * @returns A Promise that resolves to the ShippingPrice entities for the store.
+   */
+  async listByStore(storeId) {
+    const response = await this.list({ params: { storeId } });
+    return response.data;
+  }
+};
+
 // src/core/entities/order.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
   OrderStatus2["draft"] = "draft";
@@ -376,6 +917,44 @@ var ShippingMethodPolicy = /* @__PURE__ */ ((ShippingMethodPolicy2) => {
   return ShippingMethodPolicy2;
 })(ShippingMethodPolicy || {});
 
+// src/core/entities/shipping_price.ts
+var ShippingPriceStatus = /* @__PURE__ */ ((ShippingPriceStatus2) => {
+  ShippingPriceStatus2["draft"] = "draft";
+  ShippingPriceStatus2["published"] = "published";
+  return ShippingPriceStatus2;
+})(ShippingPriceStatus || {});
+function getShippingPrice(prices, countryCode, stateCode, type) {
+  const countryRates = prices[countryCode];
+  if (!countryRates) return null;
+  const stateRates = countryRates[stateCode];
+  if (!stateRates) return null;
+  return stateRates[type] ?? null;
+}
+function isShippingAvailable(prices, countryCode, stateCode) {
+  const countryRates = prices[countryCode];
+  if (!countryRates) return false;
+  const stateRates = countryRates[stateCode];
+  if (!stateRates) return false;
+  return stateRates.home !== null || stateRates.desk !== null || stateRates.pickup !== null;
+}
+function getAvailableShippingTypes(prices, countryCode, stateCode) {
+  const countryRates = prices[countryCode];
+  if (!countryRates) return [];
+  const stateRates = countryRates[stateCode];
+  if (!stateRates) return [];
+  const available = [];
+  if (stateRates.home !== null) {
+    available.push({ type: "home", price: stateRates.home });
+  }
+  if (stateRates.desk !== null) {
+    available.push({ type: "desk", price: stateRates.desk });
+  }
+  if (stateRates.pickup !== null) {
+    available.push({ type: "pickup", price: stateRates.pickup });
+  }
+  return available;
+}
+
 // src/feeef/services/service.ts
 var NotifiableService = class {
   // Array of listeners (functions) to notify when changes occur
@@ -422,6 +1001,10 @@ var CartService = class extends NotifiableService {
   items = [];
   // Array to support multiple items with same product but different variants
   shippingMethod = null;
+  shippingPrice = null;
+  // New shipping price system
+  store = null;
+  // Store entity for accessing shippingPriceId
   shippingAddress = {
     name: null,
     phone: null,
@@ -773,6 +1356,7 @@ var CartService = class extends NotifiableService {
     const store = method?.defaultShippingRates ? method : null;
     const shippingMethod = method?.rates ? method : null;
     if (store) {
+      this.store = store;
       this.shippingMethod = {
         id: store.id,
         name: store.name,
@@ -804,25 +1388,231 @@ var CartService = class extends NotifiableService {
       throw new Error("Invalid shipping method");
     }
   }
-  // getAvailableShippingTypes
   /**
-   * Retrieves the available shipping types for the current shipping method.
+   * Sets the shipping price (new system).
+   * @param shippingPrice - The shipping price entity.
+   * @param notify - Whether to notify listeners.
+   */
+  setShippingPrice(shippingPrice, notify = true) {
+    this.shippingPrice = shippingPrice;
+    if (notify) {
+      this.notify();
+    }
+  }
+  /**
+   * Sets the store entity.
+   * @param store - The store entity.
+   * @param notify - Whether to notify listeners.
+   */
+  setStore(store, notify = true) {
+    this.store = store;
+    if (notify) {
+      this.notify();
+    }
+  }
+  /**
+   * Maps ShippingType enum to ShippingPriceType string.
+   * @param shippingType - The shipping type enum.
+   * @returns The corresponding shipping price type.
+   */
+  mapShippingTypeToPriceType(shippingType) {
+    switch (shippingType) {
+      case "home" /* home */:
+        return "home";
+      case "pickup" /* pickup */:
+        return "pickup";
+      case "store" /* store */:
+        return "desk";
+      default:
+        return "home";
+    }
+  }
+  /**
+   * Resolves shipping price using the priority chain.
+   * Priority: 1. Product shippingPriceId, 2. Store shippingPriceId, 3. Product shippingMethodId, 4. Store defaultShippingRates
    *
-   *   rates is a 2D array for example `[[10, 20, 30], [5, 10, 15]]`
-   *   where the first array is for `home` fees and the second is for `pickup` fees, and the third is for `store` fees
-   *   if the fee value is 0, then it's free shipping, and if it's null, then it's not available
+   * Note: Shipping prices must be loaded and set via setShippingPrice() for the new system to work.
+   * If shipping prices are not loaded, the method falls back to the legacy system.
+   *
+   * @param countryCode - ISO 3166-1 alpha-2 country code (optional, required for new system)
+   * @param stateCode - State/province code
+   * @param shippingType - The shipping type
+   * @returns The shipping price or null if not available
+   */
+  resolveShippingPrice(countryCode, stateCode, shippingType) {
+    if (!stateCode) return null;
+    const priceType = this.mapShippingTypeToPriceType(shippingType);
+    const allProducts = [...this.items];
+    if (this.currentItem && !this.hasItem(this.currentItem)) {
+      allProducts.push(this.currentItem);
+    }
+    console.log("[resolveShippingPrice]", {
+      countryCode,
+      stateCode,
+      shippingType,
+      priceType,
+      hasShippingPrice: !!this.shippingPrice,
+      shippingPriceId: this.shippingPrice?.id,
+      allProductsCount: allProducts.length
+    });
+    if (countryCode && this.shippingPrice) {
+      const productShippingPriceIds = allProducts.map((item) => item.product.shippingPriceId).filter((id) => id !== null);
+      console.log("[resolveShippingPrice] Product shippingPriceIds:", productShippingPriceIds);
+      if (productShippingPriceIds.length > 0) {
+        const uniqueIds = new Set(productShippingPriceIds);
+        if (uniqueIds.size === 1 && this.shippingPrice.id === productShippingPriceIds[0]) {
+          console.log(
+            "[resolveShippingPrice] Using product shippingPriceId:",
+            productShippingPriceIds[0]
+          );
+          const price = getShippingPrice(
+            this.shippingPrice.prices,
+            countryCode,
+            stateCode,
+            priceType
+          );
+          console.log("[resolveShippingPrice] Product price result:", price);
+          if (price !== null) {
+            return price;
+          }
+        }
+      }
+    }
+    if (countryCode && this.store?.shippingPriceId && this.shippingPrice && this.shippingPrice.id === this.store.shippingPriceId) {
+      console.log("[resolveShippingPrice] Using store shippingPriceId:", this.store.shippingPriceId);
+      const price = getShippingPrice(
+        this.shippingPrice.prices,
+        countryCode,
+        stateCode,
+        priceType
+      );
+      console.log("[resolveShippingPrice] Store price result:", price);
+      if (price !== null) {
+        return price;
+      }
+    }
+    const productShippingMethodIds = allProducts.map((item) => item.product.shippingMethodId).filter((id) => id !== null);
+    if (productShippingMethodIds.length > 0) {
+      const uniqueIds = new Set(productShippingMethodIds);
+      if (uniqueIds.size === 1 && this.shippingMethod && this.shippingMethod.id === productShippingMethodIds[0]) {
+        const legacyPrice = this.getShippingPriceForTypeLegacy(shippingType);
+        if (legacyPrice !== null) {
+          return legacyPrice;
+        }
+      }
+    }
+    if (this.shippingMethod?.rates) {
+      console.log("[resolveShippingPrice] Falling back to legacy system");
+      const legacyPrice = this.getShippingPriceForTypeLegacy(shippingType);
+      console.log("[resolveShippingPrice] Legacy price result:", legacyPrice);
+      return legacyPrice;
+    }
+    console.log("[resolveShippingPrice] No shipping price found, returning null");
+    return null;
+  }
+  /**
+   * Gets shipping price using legacy system (array-based rates).
+   * @param type - The shipping type
+   * @returns The shipping price or null if not available
+   */
+  getShippingPriceForTypeLegacy(type) {
+    if (!this.shippingMethod?.rates || !this.shippingAddress.state) return null;
+    const stateIndex = Number.parseInt(this.shippingAddress.state, 10) - 1;
+    const rates = this.shippingMethod.rates[stateIndex];
+    if (!rates) return null;
+    switch (type) {
+      case "pickup" /* pickup */:
+        return rates[0];
+      case "home" /* home */:
+        return rates[1];
+      case "store" /* store */:
+        return rates[2];
+      default:
+        return null;
+    }
+  }
+  /**
+   * Retrieves the available shipping types using the priority chain.
+   * Priority: 1. Product shippingPriceId, 2. Store shippingPriceId, 3. Product shippingMethodId, 4. Store defaultShippingRates
+   *
+   * Note: Shipping prices must be loaded and set via setShippingPrice() for the new system to work.
+   * If shipping prices are not loaded, the method falls back to the legacy system.
    *
    * @returns An array of available shipping types.
    */
   getAvailableShippingTypes() {
+    if (!this.shippingAddress.state) return [];
+    let countryCode;
+    if (this.shippingAddress.country && this.shippingAddress.country.toLowerCase() !== "dz") {
+      countryCode = this.shippingAddress.country.toUpperCase();
+    } else if (this.store?.configs?.selectedCountry) {
+      countryCode = this.store.configs.selectedCountry.toUpperCase();
+    } else {
+      countryCode = void 0;
+    }
+    const allProducts = [...this.items];
+    if (this.currentItem && !this.hasItem(this.currentItem)) {
+      allProducts.push(this.currentItem);
+    }
+    if (countryCode && this.shippingPrice) {
+      const productShippingPriceIds = allProducts.map((item) => item.product.shippingPriceId).filter((id) => id !== null);
+      if (productShippingPriceIds.length > 0) {
+        const uniqueIds = new Set(productShippingPriceIds);
+        if (uniqueIds.size === 1 && this.shippingPrice.id === productShippingPriceIds[0]) {
+          const available = getAvailableShippingTypes(
+            this.shippingPrice.prices,
+            countryCode,
+            this.shippingAddress.state
+          );
+          if (available.length > 0) {
+            return available.map((a) => {
+              switch (a.type) {
+                case "home":
+                  return "home" /* home */;
+                case "pickup":
+                  return "pickup" /* pickup */;
+                case "desk":
+                  return "store" /* store */;
+                default:
+                  return "home" /* home */;
+              }
+            });
+          }
+        }
+      }
+    }
+    if (countryCode && this.store?.shippingPriceId && this.shippingPrice && this.shippingPrice.id === this.store.shippingPriceId) {
+      const available = getAvailableShippingTypes(
+        this.shippingPrice.prices,
+        countryCode,
+        this.shippingAddress.state
+      );
+      if (available.length > 0) {
+        return available.map((a) => {
+          switch (a.type) {
+            case "home":
+              return "home" /* home */;
+            case "pickup":
+              return "pickup" /* pickup */;
+            case "desk":
+              return "store" /* store */;
+            default:
+              return "home" /* home */;
+          }
+        });
+      }
+    }
     if (!this.shippingMethod?.rates) return [];
-    var state = Number.parseInt(this.shippingAddress.state);
-    var stateRates = this.shippingMethod.rates[state - 1];
+    const state = Number.parseInt(this.shippingAddress.state, 10);
+    const stateRates = this.shippingMethod.rates[state - 1];
     if (!stateRates) return [];
-    var availableTypes = [];
-    if (stateRates[0] || stateRates[0] === 0) availableTypes.push("pickup" /* pickup */);
-    if (stateRates[1] || stateRates[1] === 0) availableTypes.push("home" /* home */);
-    if (stateRates[2] || stateRates[2] === 0) availableTypes.push("store" /* store */);
+    const availableTypes = [];
+    if (stateRates[0] !== null && stateRates[0] !== void 0)
+      availableTypes.push("pickup" /* pickup */);
+    if (stateRates[1] !== null && stateRates[1] !== void 0)
+      availableTypes.push("home" /* home */);
+    if (stateRates[2] !== null && stateRates[2] !== void 0)
+      availableTypes.push("store" /* store */);
     return availableTypes;
   }
   /**
@@ -856,43 +1646,71 @@ var CartService = class extends NotifiableService {
    * @returns The shipping price or 0 if not applicable.
    */
   getShippingPrice() {
-    for (const item of this.items) {
+    const allItems = [...this.items];
+    if (this.currentItem && !this.hasItem(this.currentItem)) {
+      allItems.push(this.currentItem);
+    }
+    for (const item of allItems) {
       if (item.offer?.freeShipping) return 0;
     }
     if (!this.shippingMethod) return 0;
     if (!this.shippingAddress.state) return this.shippingMethod.price ?? 0;
     const shippings = this.getAvailableShippingTypes();
     const currentOne = this.getShippingPriceForType(this.shippingAddress.type);
-    if (currentOne) {
+    if (currentOne !== null) {
       return currentOne;
     }
     for (const type of shippings) {
-      if (this.getShippingPriceForType(type) !== null) {
-        return this.getShippingPriceForType(type);
+      const price = this.getShippingPriceForType(type);
+      if (price !== null) {
+        return price;
       }
     }
     return 0;
   }
   /**
-   * Gets the shipping price for a specific shipping type using the current shipping address state.
+   * Gets the shipping price for a specific shipping type using the priority chain.
+   * Priority: 1. Product shippingPriceId, 2. Store shippingPriceId, 3. Product shippingMethodId, 4. Store defaultShippingRates
    * @param type - The shipping type to check (pickup, home, store)
    * @returns The shipping price for the specified type, or null if not available
    */
   getShippingPriceForType(type) {
-    if (!this.shippingMethod?.rates || !this.shippingAddress.state) return null;
-    const stateIndex = Number.parseInt(this.shippingAddress.state, 10) - 1;
-    const rates = this.shippingMethod.rates[stateIndex];
-    if (!rates) return null;
-    switch (type) {
-      case "pickup" /* pickup */:
-        return rates[0];
-      case "home" /* home */:
-        return rates[1];
-      case "store" /* store */:
-        return rates[2];
-      default:
-        return null;
+    if (!this.shippingAddress.state) {
+      console.log("[getShippingPriceForType] No state, returning null");
+      return null;
+    }
+    let countryCode;
+    if (this.shippingAddress.country && this.shippingAddress.country.toLowerCase() !== "dz") {
+      countryCode = this.shippingAddress.country.toUpperCase();
+    } else if (this.store?.configs?.selectedCountry) {
+      countryCode = this.store.configs.selectedCountry.toUpperCase();
+    } else {
+      countryCode = void 0;
     }
+    console.log("[getShippingPriceForType]", {
+      type,
+      state: this.shippingAddress.state,
+      country: this.shippingAddress.country,
+      countryCode,
+      storeSelectedCountry: this.store?.configs?.selectedCountry,
+      hasShippingPrice: !!this.shippingPrice,
+      shippingPriceId: this.shippingPrice?.id
+    });
+    if (countryCode) {
+      const newSystemPrice = this.resolveShippingPrice(
+        countryCode,
+        this.shippingAddress.state,
+        type
+      );
+      if (newSystemPrice !== null) {
+        console.log("[getShippingPriceForType] New system price:", newSystemPrice);
+        return newSystemPrice;
+      }
+    }
+    console.log("[getShippingPriceForType] Falling back to legacy system");
+    const legacyPrice = this.getShippingPriceForTypeLegacy(type);
+    console.log("[getShippingPriceForType] Legacy price:", legacyPrice);
+    return legacyPrice;
   }
   /**
    * Calculates the total cost of the cart including shipping.
@@ -1007,10 +1825,34 @@ var FeeeF = class {
    * The repository for managing deposits.
    */
   deposits;
+  /**
+   * The repository for managing transfers.
+   */
+  transfers;
   /**
    * The repository for managing categories.
    */
   categories;
+  /**
+   * The repository for managing countries.
+   */
+  countries;
+  /**
+   * The repository for managing states.
+   */
+  states;
+  /**
+   * The repository for managing cities.
+   */
+  cities;
+  /**
+   * The repository for managing currencies.
+   */
+  currencies;
+  /**
+   * The repository for managing shipping prices.
+   */
+  shippingPrices;
   /**
    * The cart service for managing the cart.
    */
@@ -1038,7 +1880,13 @@ var FeeeF = class {
     this.users = new UserRepository(this.client);
     this.orders = new OrderRepository(this.client);
     this.deposits = new DepositRepository(this.client);
+    this.transfers = new TransferRepository(this.client);
     this.categories = new CategoryRepository(this.client);
+    this.countries = new CountryRepository(this.client);
+    this.states = new StateRepository(this.client);
+    this.cities = new CityRepository(this.client);
+    this.currencies = new CurrencyRepository(this.client);
+    this.shippingPrices = new ShippingPriceRepository(this.client);
     this.cart = new CartService();
     this.actions = new ActionsService(this.client);
   }
@@ -1413,12 +2261,16 @@ export {
   ProductVariantView,
   ShippingMethodPolicy,
   ShippingMethodStatus,
+  ShippingPriceRepository,
+  ShippingPriceStatus,
   ShippingType,
   StoreActionType,
   StoreMemberRole,
   StoreSubscriptionStatus,
   StoreSubscriptionType,
   TiktokPixelEvent,
+  TransferRepository,
+  UserRepository,
   VariantOptionType,
   WebhookEvent,
   convertDartColorToCssNumber,
@@ -1441,6 +2293,9 @@ export {
   generatePublicStoreIntegrationTiktokPixel,
   generatePublicStoreIntegrationWebhooks,
   generatePublicStoreIntegrations,
+  getAvailableShippingTypes,
+  getShippingPrice,
+  isShippingAvailable,
   tryFixPhoneNumber,
   validatePhoneNumber
 };