@akinon/next 2.0.0-beta.2 → 2.0.0-beta.20

package/components/theme-editor/utils/iterator-utils.ts

@@ -0,0 +1,234 @@
+import { Block } from '../theme-block';
+
+interface IteratorOptions {
+  iteratorBlock: Block;
+  sectionDataSource?: any;
+  isDesigner?: boolean;
+  forceIteratorCount?: number;
+  forceIteratorOffset?: number;
+}
+
+const parsePositiveNumber = (value: unknown, fallback: number): number => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return Math.max(0, Math.floor(value));
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return Math.max(0, Math.floor(parsed));
+    }
+  }
+  return fallback;
+};
+
+const extractProducts = (
+  collectionData: any,
+  dataPath: string | undefined
+): Record<string, unknown>[] | null => {
+  if (!collectionData) return null;
+
+  // Respect explicit iterator path first.
+  if (dataPath) {
+    if (Array.isArray(collectionData)) {
+      if (dataPath === 'products' || dataPath === 'items') {
+        return collectionData as Record<string, unknown>[];
+      }
+    } else if (collectionData && typeof collectionData === 'object') {
+      const pathParts = dataPath.split('.');
+      let value: unknown = collectionData;
+
+      for (const part of pathParts) {
+        value = (value as Record<string, unknown>)?.[part];
+        if (value === undefined) break;
+      }
+
+      if (Array.isArray(value)) {
+        return value as Record<string, unknown>[];
+      }
+    }
+  }
+
+  // Fallback to generic products array for backward compatibility.
+  if (Array.isArray(collectionData)) {
+    return collectionData as Record<string, unknown>[];
+  }
+
+  if (Array.isArray((collectionData as any)?.products)) {
+    return (collectionData as any).products;
+  }
+
+  return null;
+};
+
+const getProductsFromDataSource = (
+  sectionDataSource: any,
+  dataPath: string | undefined,
+  isDesigner: boolean
+): Record<string, unknown>[] => {
+  if (!sectionDataSource?.details) {
+    return [];
+  }
+
+  const isEditorMode =
+    isDesigner && typeof window !== 'undefined' && window.parent !== window;
+
+  const collection = sectionDataSource.details.collection;
+
+  // In editor mode, prefer live products; on storefront, prefer fetched data.
+  // Fall back to the other source if the primary one yields no products.
+  const candidates = isEditorMode
+    ? [collection?.products, collection?.data]
+    : [collection?.data, collection?.products];
+
+  for (const candidate of candidates) {
+    const products = extractProducts(candidate, dataPath);
+    if (products && products.length > 0) {
+      return products;
+    }
+  }
+
+  return [];
+};
+
+const replaceBlockValues = (
+  blockToReplace: Block,
+  productData: Record<string, unknown>,
+  productIndex: number
+): Block => {
+  const newBlock: Block = {
+    ...blockToReplace,
+    properties: blockToReplace.properties
+      ? { ...blockToReplace.properties }
+      : blockToReplace.properties
+  };
+
+  const isPlaceholderMode = !productData || Object.keys(productData).length === 0;
+
+  if (newBlock.properties?.dataBinding && !isPlaceholderMode) {
+    const bindingPath = newBlock.properties.dataBinding.replace('item.', '');
+    const pathParts = bindingPath.split('.');
+
+    let value: unknown = productData;
+    for (const part of pathParts) {
+      const arrayMatch = part.match(/^(.+)\[(\d+)\]$/);
+      if (arrayMatch) {
+        const [, arrayName, indexStr] = arrayMatch;
+        const obj = value as Record<string, unknown>;
+        const arr = obj?.[arrayName];
+        if (Array.isArray(arr)) {
+          value = arr[parseInt(indexStr, 10)];
+        } else {
+          value = undefined;
+        }
+      } else {
+        value = (value as Record<string, unknown>)?.[part];
+      }
+      if (value === undefined) break;
+    }
+
+    if (value !== undefined) {
+      if (newBlock.properties.tag === 'a') {
+        newBlock.properties = {
+          ...newBlock.properties,
+          href: value
+        };
+      } else {
+        newBlock.value = value;
+      }
+    }
+  } else if (isPlaceholderMode && newBlock.type === 'image') {
+    const placeholderImages = [
+      '/assets/images/product-placeholder-1.jpg',
+      '/assets/images/product-placeholder-2.jpg',
+      '/assets/images/product-placeholder-3.jpg',
+      '/assets/images/product-placeholder-4.jpg'
+    ];
+
+    const placeholderIndex = productIndex % placeholderImages.length;
+
+    if (
+      newBlock.value &&
+      typeof newBlock.value === 'string' &&
+      newBlock.value.includes('product-placeholder')
+    ) {
+      newBlock.value = placeholderImages[placeholderIndex];
+    }
+  }
+
+  if (newBlock.blocks && newBlock.blocks.length > 0) {
+    newBlock.blocks = newBlock.blocks.map(childBlock =>
+      replaceBlockValues(childBlock, productData, productIndex)
+    );
+  }
+
+  return newBlock;
+};
+
+export const buildIteratorBlock = ({
+  iteratorBlock,
+  sectionDataSource,
+  isDesigner = false,
+  forceIteratorCount,
+  forceIteratorOffset
+}: IteratorOptions): Block => {
+  if (
+    !iteratorBlock.isIterator ||
+    !iteratorBlock.blocks ||
+    iteratorBlock.blocks.length === 0
+  ) {
+    return iteratorBlock;
+  }
+
+  const template = iteratorBlock.blocks[0];
+  const dataPath =
+    iteratorBlock.iteratorDataPath || iteratorBlock.properties?.iteratorDataPath;
+  const products = getProductsFromDataSource(
+    sectionDataSource,
+    dataPath,
+    isDesigner
+  );
+
+  const useIteratorCount =
+    forceIteratorCount !== undefined
+      ? true
+      : iteratorBlock.properties?.useIteratorCount === true ||
+        iteratorBlock.properties?.useIteratorCount === 'true';
+  const iteratorCount =
+    forceIteratorCount !== undefined
+      ? Math.max(1, Math.floor(forceIteratorCount))
+      : parsePositiveNumber(iteratorBlock.properties?.iteratorCount, 1);
+  const iteratorOffset =
+    forceIteratorOffset !== undefined
+      ? Math.max(0, Math.floor(forceIteratorOffset))
+      : parsePositiveNumber(iteratorBlock.properties?.iteratorOffset, 0);
+
+  const displayProducts =
+    products.length > 0
+      ? useIteratorCount
+        ? products.slice(iteratorOffset, iteratorOffset + iteratorCount)
+        : products
+      : [];
+
+  const actualCount =
+    displayProducts.length > 0 ? displayProducts.length : Math.max(iteratorCount, 1);
+
+  const clonedBlocks = Array.from({ length: actualCount }, (_, index) => {
+    const product = displayProducts[index] || {};
+
+    const templateCopy: Block = {
+      ...template,
+      id: `${template.id}-clone-${index}`,
+      properties: template.properties
+        ? { ...template.properties }
+        : template.properties,
+      blocks: template.blocks ? template.blocks.map(b => ({ ...b })) : undefined
+    };
+
+    return replaceBlockValues(templateCopy, product, index);
+  });
+
+  return {
+    ...iteratorBlock,
+    blocks: clonedBlocks
+  };
+};

package/components/theme-editor/utils/publish-window.ts

@@ -0,0 +1,86 @@
+export interface PublishWindowValue {
+  enabled?: boolean;
+  startAt?: string;
+  endAt?: string;
+}
+
+export type PublishWindowStatus =
+  | 'inactive'
+  | 'scheduled'
+  | 'active'
+  | 'expired';
+
+const isPublishWindowShape = (value: unknown): value is PublishWindowValue => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  const candidate = value as Record<string, unknown>;
+  return (
+    candidate.enabled !== undefined ||
+    candidate.startAt !== undefined ||
+    candidate.endAt !== undefined
+  );
+};
+
+export const normalizePublishWindowValue = (
+  value: unknown
+): PublishWindowValue => {
+  if (isPublishWindowShape(value)) {
+    return {
+      enabled: value.enabled === true,
+      startAt: typeof value.startAt === 'string' ? value.startAt : '',
+      endAt: typeof value.endAt === 'string' ? value.endAt : ''
+    };
+  }
+
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const responsiveValue = value as Record<string, unknown>;
+    const nestedValue =
+      responsiveValue.desktop ||
+      responsiveValue.mobile ||
+      responsiveValue.tablet;
+
+    if (nestedValue && nestedValue !== value) {
+      return normalizePublishWindowValue(nestedValue);
+    }
+  }
+
+  return {
+    enabled: false,
+    startAt: '',
+    endAt: ''
+  };
+};
+
+const parsePublishTime = (value?: string): number | null => {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+export const getPublishWindowStatus = (
+  value: unknown,
+  now: Date = new Date()
+): PublishWindowStatus => {
+  const publishWindow = normalizePublishWindowValue(value);
+
+  if (!publishWindow.enabled) return 'inactive';
+
+  const currentTime = now.getTime();
+  const startAt = parsePublishTime(publishWindow.startAt);
+  const endAt = parsePublishTime(publishWindow.endAt);
+
+  if (startAt !== null && currentTime < startAt) return 'scheduled';
+  if (endAt !== null && currentTime > endAt) return 'expired';
+
+  return 'active';
+};
+
+export const isPublishWindowVisible = (
+  value: unknown,
+  now: Date = new Date()
+): boolean => {
+  const status = getPublishWindowStatus(value, now);
+  return status === 'inactive' || status === 'active';
+};

package/components/theme-editor/utils/visibility-rules.ts

@@ -0,0 +1,188 @@
+import { Block } from '../theme-block';
+import { Section } from '../theme-section';
+
+export type VisibilityAuthState = 'all' | 'authenticated' | 'guest';
+export type VisibilityPathMatchType =
+  | 'any'
+  | 'equals'
+  | 'contains'
+  | 'startsWith';
+
+export interface VisibilityRules {
+  enabled?: boolean;
+  authState?: VisibilityAuthState;
+  allowedBreakpoints?: string[];
+  allowedLocales?: string[];
+  allowedCurrencies?: string[];
+  pathnameMatchType?: VisibilityPathMatchType;
+  pathnameValue?: string;
+  queryParamKey?: string;
+  queryParamValue?: string;
+}
+
+export interface VisibilityRuleContext {
+  authState: 'authenticated' | 'guest' | 'loading';
+  breakpoint: string;
+  locale: string;
+  currency: string;
+  pathname: string;
+  searchParams?: {
+    get: (key: string) => string | null;
+  } | null;
+}
+
+const normalizeStringArray = (value: unknown): string[] => {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map(item => String(item || '').trim())
+    .filter(Boolean);
+};
+
+export const normalizeVisibilityRules = (value: unknown): VisibilityRules => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {
+      enabled: false,
+      authState: 'all',
+      allowedBreakpoints: [],
+      allowedLocales: [],
+      allowedCurrencies: [],
+      pathnameMatchType: 'any',
+      pathnameValue: '',
+      queryParamKey: '',
+      queryParamValue: ''
+    };
+  }
+
+  const rules = value as Record<string, unknown>;
+  return {
+    enabled: rules.enabled === true,
+    authState:
+      rules.authState === 'authenticated' || rules.authState === 'guest'
+        ? rules.authState
+        : 'all',
+    allowedBreakpoints: normalizeStringArray(rules.allowedBreakpoints),
+    allowedLocales: normalizeStringArray(rules.allowedLocales),
+    allowedCurrencies: normalizeStringArray(rules.allowedCurrencies).map(item =>
+      item.toUpperCase()
+    ),
+    pathnameMatchType:
+      rules.pathnameMatchType === 'equals' ||
+      rules.pathnameMatchType === 'contains' ||
+      rules.pathnameMatchType === 'startsWith'
+        ? rules.pathnameMatchType
+        : 'any',
+    pathnameValue: String(rules.pathnameValue || '').trim(),
+    queryParamKey: String(rules.queryParamKey || '').trim(),
+    queryParamValue: String(rules.queryParamValue || '').trim()
+  };
+};
+
+export const evaluateVisibilityRules = (
+  rawRules: unknown,
+  context: VisibilityRuleContext
+): boolean => {
+  const rules = normalizeVisibilityRules(rawRules);
+  if (!rules.enabled) return true;
+
+  if (rules.authState && rules.authState !== 'all') {
+    if (context.authState === 'loading') return false;
+    if (rules.authState === 'authenticated') {
+      if (context.authState !== 'authenticated') return false;
+    } else if (context.authState !== 'guest') {
+      return false;
+    }
+  }
+
+  if (
+    rules.allowedBreakpoints &&
+    rules.allowedBreakpoints.length > 0 &&
+    !rules.allowedBreakpoints.includes(context.breakpoint)
+  ) {
+    return false;
+  }
+
+  if (
+    rules.allowedLocales &&
+    rules.allowedLocales.length > 0 &&
+    !rules.allowedLocales.includes(context.locale)
+  ) {
+    return false;
+  }
+
+  if (
+    rules.allowedCurrencies &&
+    rules.allowedCurrencies.length > 0 &&
+    !rules.allowedCurrencies.includes(String(context.currency || '').toUpperCase())
+  ) {
+    return false;
+  }
+
+  const pathname = String(context.pathname || '');
+  if (rules.pathnameMatchType && rules.pathnameMatchType !== 'any') {
+    const ruleValue = String(rules.pathnameValue || '').trim();
+    if (!ruleValue) return false;
+
+    if (rules.pathnameMatchType === 'equals' && pathname !== ruleValue) {
+      return false;
+    }
+
+    if (
+      rules.pathnameMatchType === 'contains' &&
+      !pathname.includes(ruleValue)
+    ) {
+      return false;
+    }
+
+    if (
+      rules.pathnameMatchType === 'startsWith' &&
+      !pathname.startsWith(ruleValue)
+    ) {
+      return false;
+    }
+  }
+
+  if (rules.queryParamKey) {
+    const actualValue = context.searchParams?.get(rules.queryParamKey) ?? null;
+    if (actualValue === null) return false;
+    if (rules.queryParamValue && actualValue !== rules.queryParamValue) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const applyBlockVisibility = (
+  block: Block,
+  context: VisibilityRuleContext
+): Block => {
+  const blocks = block.blocks?.map(child => applyBlockVisibility(child, context));
+  const isVisibleByRules = evaluateVisibilityRules(
+    block.properties?.visibilityRules,
+    context
+  );
+
+  return {
+    ...block,
+    hidden: Boolean(block.hidden) || !isVisibleByRules,
+    blocks
+  };
+};
+
+export const applyVisibilityRulesToSections = (
+  sections: Section[],
+  context: VisibilityRuleContext
+): Section[] =>
+  sections.map(section => {
+    const blocks = section.blocks.map(block => applyBlockVisibility(block, context));
+    const isVisibleByRules = evaluateVisibilityRules(
+      section.properties?.visibilityRules,
+      context
+    );
+
+    return {
+      ...section,
+      hidden: Boolean(section.hidden) || !isVisibleByRules,
+      blocks
+    };
+  });

package/data/client/account.ts

@@ -7,6 +7,7 @@ import {
   AccountOrderCancellation,
   AccountOrderCancellationReason,
   ContactFormType,
+  LoyaltyBalanceItem,
   Order,
   Quotations
 } from '../../types';
@@ -77,6 +78,10 @@ interface LoyaltyTransactions {
   }[];
 }
 
+interface PasswordResetValidateResponse {
+  validlink: boolean;
+}
+
 const accountApi = api.injectEndpoints({
   endpoints: (builder) => ({
     updatePassword: builder.mutation<void, AccountChangePasswordFormType>({
@@ -216,11 +221,20 @@ const accountApi = api.injectEndpoints({
         method: 'PATCH'
       })
     }),
-    getLoyaltyBalance: builder.query<{ balance: number }, void>({
+    getLoyaltyBalance: builder.query<
+      { balance: number; balances?: LoyaltyBalanceItem[] },
+      void
+    >({
       query: () => buildClientRequestUrl(account.loyaltyBalance)
     }),
     getLoyaltyTransactions: builder.query<LoyaltyTransactions, void>({
       query: () => buildClientRequestUrl(account.loyaltyTransactions)
+    }),
+    getValidatePasswordResetToken: builder.query<
+      PasswordResetValidateResponse,
+      string
+    >({
+      query: (slug) => buildClientRequestUrl(account.passwordReset(slug))
     })
   }),
   overrideExisting: true
@@ -247,5 +261,6 @@ export const {
   usePasswordResetMutation,
   useAnonymizeMutation,
   useGetLoyaltyBalanceQuery,
-  useGetLoyaltyTransactionsQuery
+  useGetLoyaltyTransactionsQuery,
+  useGetValidatePasswordResetTokenQuery
 } = accountApi;

package/data/client/api.ts

@@ -68,10 +68,12 @@ export const api = createApi({
   tagTypes: [
     'Basket',
     'MultiBasket',
+    'MiniBasket',
     'BasketB2b',
     'DraftsB2b',
     'Product',
     'Checkout',
+    'PaymentOptions',
     'Favorite',
     'Addresses',
     'Profile',

package/data/client/basket.ts

@@ -24,6 +24,26 @@ export const basketApi = api.injectEndpoints({
       transformResponse: (response: { basket: Basket }) => response.basket,
       providesTags: ['Basket']
     }),
+    getMiniBasket: build.query<
+      { pk: number | null; total_quantity: number },
+      void
+    >({
+      query: () =>
+        buildClientRequestUrl(basket.getMiniBasket, {
+          contentType: 'application/json'
+        }),
+      providesTags: ['MiniBasket']
+    }),
+    getMiniBasketDetail: build.query<
+      { pk: number | null; total_quantity: number },
+      { namespace: string }
+    >({
+      query: ({ namespace }) =>
+        buildClientRequestUrl(basket.getMiniBasketDetail(namespace), {
+          contentType: 'application/json'
+        }),
+      providesTags: ['MiniBasket']
+    }),
     getBasketDetail: build.query<Basket, { namespace: string }>({
       query: ({ namespace }) =>
         buildClientRequestUrl(basket.getBasketDetail(namespace)),
@@ -46,7 +66,7 @@ export const basketApi = api.injectEndpoints({
         method: 'DELETE',
         body: { pk }
       }),
-      invalidatesTags: ['MultiBasket', 'Basket']
+      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
     }),
     selectMainBasket: build.mutation<Basket, { pk: number }>({
       query: ({ pk }) => ({
@@ -57,7 +77,7 @@ export const basketApi = api.injectEndpoints({
         body: { pk }
       }),
       transformResponse: (response: { baskets: Basket }) => response.baskets,
-      invalidatesTags: ['MultiBasket', 'Basket']
+      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
     }),
     selectNameSpaceMainBasket: build.mutation<Basket, { namespace: string }>({
       query: ({ namespace }) => ({
@@ -71,7 +91,7 @@ export const basketApi = api.injectEndpoints({
         body: { namespace }
       }),
       transformResponse: (response: { baskets: Basket }) => response.baskets,
-      invalidatesTags: ['MultiBasket', 'Basket']
+      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
     }),
     updateQuantity: build.mutation<
       UpdateQuantityResponse,
@@ -84,7 +104,46 @@ export const basketApi = api.injectEndpoints({
         method: 'PUT',
         body
       }),
-      invalidatesTags: ['MultiBasket', 'Basket']
+      async onQueryStarted(_, { dispatch, queryFulfilled }) {
+        try {
+          const { data } = await queryFulfilled;
+
+          dispatch(
+            basketApi.util.updateQueryData(
+              'getBasket',
+              undefined,
+              () => data.basket
+            )
+          );
+
+          if (data.basket.namespace) {
+            dispatch(
+              basketApi.util.updateQueryData(
+                'getBasketDetail',
+                { namespace: data.basket.namespace },
+                () => data.basket
+              )
+            );
+          }
+
+          dispatch(
+            basketApi.util.updateQueryData(
+              'getAllBaskets',
+              undefined,
+              (baskets) => {
+                if (!baskets) return baskets;
+
+                return baskets.map((basket) =>
+                  basket.pk === data.basket.pk ? data.basket : basket
+                );
+              }
+            )
+          );
+        } catch (error) {
+          console.error('Error updating quantity:', error);
+        }
+      },
+      invalidatesTags: ['MultiBasket', 'Basket', 'MiniBasket']
     }),
     clearBasket: build.mutation<Basket, void>({
       query: (body) => ({
@@ -95,7 +154,7 @@ export const basketApi = api.injectEndpoints({
         body
       }),
       transformResponse: (response: { basket: Basket }) => response.basket,
-      invalidatesTags: ['Basket']
+      invalidatesTags: ['Basket', 'MiniBasket', 'MiniBasket']
     }),
     applyVoucherCode: build.mutation<Basket, { voucher_code: string }>({
       query: (body) => ({
@@ -125,6 +184,8 @@ export const basketApi = api.injectEndpoints({
 
 export const {
   useGetBasketQuery,
+  useGetMiniBasketQuery,
+  useGetMiniBasketDetailQuery,
   useLazyGetBasketDetailQuery,
   useGetAllBasketsQuery,
   useRemoveBasketMutation,