@akinon/next 1.96.0-rc.56 → 1.96.0-snapshot-ZERO-35861-20250908151109

package/types/index.ts

@@ -83,12 +83,6 @@ export interface Settings {
   };
   usePrettyUrlRoute?: boolean;
   commerceUrl: string;
-  /**
-   * This option allows you to track Sentry events on the client side, in addition to server and edge environments.
-   *
-   * It overrides process.env.NEXT_PUBLIC_SENTRY_DSN and process.env.SENTRY_DSN.
-   */
-  sentryDsn?: string;
   redis: {
     defaultExpirationTime: number;
   };
@@ -222,6 +216,7 @@ export interface CacheOptions {
   cache?: boolean;
   expire?: number;
   useProxy?: boolean;
+  compressed?: boolean;
 }
 
 export interface SetCookieOptions {
@@ -297,13 +292,7 @@ export interface ButtonProps
   target?: '_blank' | '_self' | '_parent' | '_top';
 }
 
-export interface FileInputProps extends React.HTMLProps<HTMLInputElement> {
-  fileClassName?: string;
-  fileNameWrapperClassName?: string;
-  fileInputClassName?: string;
-  onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
-  buttonClassName?: string;
-}
+export type FileInputProps = React.HTMLProps<HTMLInputElement>;
 
 export interface PriceProps {
   currencyCode?: string;
@@ -324,19 +313,15 @@ export interface InputProps extends React.HTMLProps<HTMLInputElement> {
 
 export interface AccordionProps {
   isCollapse?: boolean;
-  collapseClassName?: string;
   title?: string;
   subTitle?: string;
   icons?: string[];
   iconSize?: number;
   iconColor?: string;
   children?: ReactNode;
-  headerClassName?: string;
   className?: string;
   titleClassName?: string;
-  subTitleClassName?: string;
   dataTestId?: string;
-  contentClassName?: string;
 }
 
 export interface PluginModuleComponentProps {
@@ -361,20 +346,3 @@ export interface PaginationProps {
   direction?: 'next' | 'prev';
   isLoading?: boolean;
 }
-
-export interface ModalProps {
-  portalId: string;
-  children?: React.ReactNode;
-  open?: boolean;
-  setOpen?: (open: boolean) => void;
-  title?: React.ReactNode;
-  showCloseButton?: React.ReactNode;
-  className?: string;
-  overlayClassName?: string;
-  headerWrapperClassName?: string;
-  titleClassName?: string;
-  closeButtonClassName?: string;
-  iconName?: string;
-  iconSize?: number;
-  iconClassName?: string;
-}

package/utils/app-fetch.ts

@@ -43,12 +43,12 @@ const appFetch = async <T>({
     const requestURL = `${decodeURIComponent(commerceUrl)}${url}`;
 
     init.headers = {
-      cookie: nextCookies.toString(),
       ...(init.headers ?? {}),
       ...(ServerVariables.globalHeaders ?? {}),
       'Accept-Language': currentLocale.apiValue,
       'x-currency': currency,
-      'x-forwarded-for': ip
+      'x-forwarded-for': ip,
+      cookie: nextCookies.toString()
     };
 
     init.next = {
@@ -60,11 +60,6 @@ const appFetch = async <T>({
     status = req.status;
     logger.debug(`FETCH END ${url}`, { status: req.status, ip });
 
-    if (!req.ok) {
-      const errorMessage = `HTTP ${req.status}: ${req.statusText}`;
-      throw new Error(errorMessage);
-    }
-
     if (responseType === FetchResponseType.JSON) {
       response = (await req.json()) as T;
     } else {

package/utils/redirect.ts

@@ -1,48 +1,23 @@
 import { redirect as nextRedirect, RedirectType } from 'next/navigation';
 import Settings from 'settings';
-import { headers, cookies } from 'next/headers';
+import { headers } from 'next/headers';
+import { ServerVariables } from '@akinon/next/utils/server-variables';
 import { getUrlPathWithLocale } from '@akinon/next/utils/localization';
-import { urlLocaleMatcherRegex } from '@akinon/next/utils';
 
 export const redirect = (path: string, type?: RedirectType) => {
   const nextHeaders = headers();
-  const nextCookies = cookies();
   const pageUrl = new URL(
-    nextHeaders.get('pz-url') ?? process.env.NEXT_PUBLIC_URL ?? ''
+    nextHeaders.get('pz-url') ?? process.env.NEXT_PUBLIC_URL
   );
 
-  let currentLocaleValue = Settings.localization.defaultLocaleValue;
-  const urlLocaleMatch = pageUrl.pathname.match(urlLocaleMatcherRegex);
-
-  if (urlLocaleMatch && urlLocaleMatch[0]) {
-    currentLocaleValue = urlLocaleMatch[0].replace('/', '');
-  } else {
-    const cookieLocale = nextCookies.get('pz-locale')?.value;
-    if (
-      cookieLocale &&
-      Settings.localization.locales.find((l) => l.value === cookieLocale)
-    ) {
-      currentLocaleValue = cookieLocale;
-    }
-  }
-
   const currentLocale = Settings.localization.locales.find(
-    (locale) => locale.value === currentLocaleValue
+    (locale) => locale.value === ServerVariables.locale
   );
 
-  if (!currentLocale) {
-    currentLocaleValue = Settings.localization.defaultLocaleValue;
-  }
-
-  const searchParams = new URLSearchParams(pageUrl.search);
-
-  const callbackUrl =
-    pageUrl.pathname.replace(urlLocaleMatcherRegex, '') +
-    (searchParams.toString() ? `?${searchParams.toString()}` : '');
-
+  const callbackUrl = pageUrl.pathname;
   const redirectUrlWithLocale = getUrlPathWithLocale(
     path,
-    currentLocale?.value
+    currentLocale.localePath ?? currentLocale.value
   );
 
   const redirectUrl = `${redirectUrlWithLocale}?callbackUrl=${callbackUrl}`;

package/with-pz-config.js

@@ -16,8 +16,12 @@ const defaultConfig = {
     remotePatterns: [
       {
         protocol: 'https',
-        hostname: '**'
+        hostname: '**.akinoncloud.com'
       },
+      {
+        protocol: 'https',
+        hostname: '**.akinoncdn.com'
+      }
     ]
   },
   modularizeImports: {

package/__tests__/redirect.test.ts

@@ -1,319 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-jest.mock(
-  'countries',
-  () => ({
-    countries: [
-      { value: 'ae', localizable: true },
-      { value: 'qa', localizable: true },
-      { value: 'sa', localizable: true }
-    ],
-    countryCurrencyMap: { ae: 'aed', qa: 'qar', sa: 'sar' },
-    countryShortCodeMap: { ae: 'uae', qa: 'qtr', sa: 'ksa' }
-  }),
-  { virtual: true }
-);
-
-jest.mock(
-  '@theme/routes',
-  () => ({
-    ROUTES: {
-      AUTH: '/auth',
-      BASKET: '/basket',
-      ACCOUNT_ORDERS: '/account/orders'
-    }
-  }),
-  { virtual: true }
-);
-
-type Locale = {
-  value: string;
-  label?: string;
-  localePath?: string;
-  apiValue?: string;
-  rtl?: boolean;
-};
-
-type Settings = {
-  localization: {
-    defaultLocaleValue: string;
-    localeUrlStrategy: string;
-    locales: Locale[];
-  };
-};
-
-function resolveSettingsPath(): string | null {
-  const insideNodeModules = __dirname.includes('node_modules');
-
-  const candidates: string[] = [];
-
-  if (insideNodeModules) {
-    const projectRoot = path.resolve(__dirname, '../../../../');
-    candidates.push(path.join(projectRoot, 'src/settings.js'));
-    candidates.push(
-      path.join(projectRoot, 'apps', 'projectzeronext', 'src', 'settings.js')
-    );
-  } else {
-    const repoRoot = path.resolve(__dirname, '../../..');
-    candidates.push(
-      path.join(repoRoot, 'apps', 'projectzeronext', 'src', 'settings.js')
-    );
-    candidates.push(path.join(repoRoot, 'src', 'settings.js'));
-  }
-
-  for (const p of candidates) {
-    if (fs.existsSync(p)) return p;
-  }
-
-  return null;
-}
-
-function loadProjectSettings(): Settings {
-  const settingsPath = resolveSettingsPath();
-  if (settingsPath) {
-    const settings: any = require(settingsPath);
-    return settings as Settings;
-  }
-
-  return {
-    localization: {
-      defaultLocaleValue: 'en',
-      localeUrlStrategy: 'hide-default-locale',
-      locales: [
-        { value: 'en', label: 'EN' },
-        { value: 'tr', label: 'TR' }
-      ]
-    }
-  };
-}
-
-function getUrlPathWithLocaleLocal(
-  pathname: string,
-  currentLocale: string | undefined,
-  settings: Settings
-): string {
-  const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
-  const effectiveLocale = currentLocale ?? defaultLocaleValue;
-
-  if (
-    localeUrlStrategy === 'subdomain' ||
-    localeUrlStrategy === 'hide-all-locales'
-  ) {
-    return pathname;
-  }
-
-  if (localeUrlStrategy === 'hide-default-locale') {
-    if (effectiveLocale === defaultLocaleValue) {
-      return pathname;
-    }
-    return `/${effectiveLocale}${pathname}`;
-  }
-
-  return `/${effectiveLocale}${pathname}`;
-}
-
-function computeUrlLocaleMatcherRegex(settings: Settings): RegExp {
-  const { locales, localeUrlStrategy, defaultLocaleValue } =
-    settings.localization;
-
-  const filtered =
-    localeUrlStrategy === 'show-all-locales' ||
-    localeUrlStrategy === 'subdomain'
-      ? locales
-      : locales.filter((l: any) => l.value !== defaultLocaleValue);
-
-  return new RegExp(
-    `^/(${filtered.map((l: any) => l.value).join('|')})(?=/|$)`
-  );
-}
-
-function redirectMinimal(
-  destPath: string,
-  pageUrlInput: string,
-  settings: Settings
-): string {
-  const regex = computeUrlLocaleMatcherRegex(settings);
-  const pageUrl = new URL(pageUrlInput);
-  let currentLocaleValue = settings.localization.defaultLocaleValue;
-
-  const match = pageUrl.pathname.match(regex);
-  if (match && match[0]) {
-    currentLocaleValue = match[0].replace('/', '');
-  }
-
-  const redirectUrlWithLocale = getUrlPathWithLocaleLocal(
-    destPath,
-    currentLocaleValue,
-    settings
-  );
-  
-  const callbackPath = pageUrl.pathname.replace(regex, '');
-
-  return `${redirectUrlWithLocale}?callbackUrl=${callbackPath}`;
-}
-
-describe('Redirect utility functional tests', () => {
-  const settings = loadProjectSettings();
-
-  function buildPageUrl(pathAfter: string, locale: string): string {
-    const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
-    const isDefault = locale === defaultLocaleValue;
-    let prefix = '';
-    if (isDefault) {
-      prefix = localeUrlStrategy === 'show-all-locales' ? `/${locale}` : '';
-    } else {
-      prefix = `/${locale}`;
-    }
-    return `https://example.com${prefix}${pathAfter}`;
-  }
-
-  describe('getUrlPathWithLocale functional tests', () => {
-    it('should respect project localeUrlStrategy dynamically', () => {
-      const { defaultLocaleValue, locales, localeUrlStrategy } =
-        settings.localization;
-
-      const nonDefault = locales.find((l) => l.value !== defaultLocaleValue);
-
-      const resultDefault = getUrlPathWithLocaleLocal(
-        '/login',
-        defaultLocaleValue,
-        settings
-      );
-      const resultNonDefault = nonDefault
-        ? getUrlPathWithLocaleLocal('/login', nonDefault.value, settings)
-        : null;
-      const resultUndefined = getUrlPathWithLocaleLocal(
-        '/login',
-        undefined,
-        settings
-      );
-
-      if (localeUrlStrategy === 'hide-default-locale') {
-        expect(resultDefault).toBe('/login');
-        if (resultNonDefault && nonDefault) {
-          expect(resultNonDefault).toBe(`/${nonDefault.value}/login`);
-        }
-        expect(resultUndefined).toBe('/login');
-      } else if (localeUrlStrategy === 'show-all-locales') {
-        expect(resultDefault).toBe(`/${defaultLocaleValue}/login`);
-        if (resultNonDefault && nonDefault) {
-          expect(resultNonDefault).toBe(`/${nonDefault.value}/login`);
-        }
-        expect(resultUndefined).toBe(`/${defaultLocaleValue}/login`);
-      } else if (localeUrlStrategy === 'hide-all-locales') {
-        expect(resultDefault).toBe('/login');
-        if (resultNonDefault) {
-          expect(resultNonDefault).toBe('/login');
-        }
-        expect(resultUndefined).toBe('/login');
-      } else if (localeUrlStrategy === 'subdomain') {
-        expect(resultDefault).toBe('/login');
-        if (resultNonDefault) {
-          expect(resultNonDefault).toBe('/login');
-        }
-        expect(resultUndefined).toBe('/login');
-      }
-    });
-  });
-
-  describe('redirect function behavior (simulated)', () => {
-    it('should redirect with correct URL for default locale (no query preserved)', () => {
-      const { defaultLocaleValue } = settings.localization;
-      const regex = computeUrlLocaleMatcherRegex(settings);
-      const url = buildPageUrl(
-        '/profile?tab=settings&view=list#frag',
-        defaultLocaleValue
-      );
-      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
-      const expectedPath = getUrlPathWithLocaleLocal(
-        '/login',
-        matched,
-        settings
-      );
-      const out = redirectMinimal('/login', url, settings);
-      expect(out).toBe(`${expectedPath}?callbackUrl=/profile`);
-    });
-
-    it('should handle non-default locale from path', () => {
-      const nonDefault = settings.localization.locales.find(
-        (l) => l.value !== settings.localization.defaultLocaleValue
-      );
-      if (!nonDefault) return;
-      const url = buildPageUrl('/products/123', nonDefault.value);
-      const regex = computeUrlLocaleMatcherRegex(settings);
-      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
-      const expectedPath = getUrlPathWithLocaleLocal(
-        '/auth',
-        matched,
-        settings
-      );
-      const out = redirectMinimal('/auth', url, settings);
-      expect(out).toBe(`${expectedPath}?callbackUrl=/products/123`);
-    });
-
-    it('should use env fallback when header missing (no query preserved)', () => {
-      const { defaultLocaleValue } = settings.localization;
-      const url = buildPageUrl('/some/path?x=1#y', defaultLocaleValue).replace(
-        'https://example.com',
-        'https://fallback.com'
-      );
-      const regex = computeUrlLocaleMatcherRegex(settings);
-      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
-      const expectedPath = getUrlPathWithLocaleLocal(
-        '/login',
-        matched,
-        settings
-      );
-      const out = redirectMinimal('/login', url, settings);
-      expect(out).toBe(`${expectedPath}?callbackUrl=/some/path`);
-    });
-
-    it('should throw with invalid URL', () => {
-      expect(() => new URL('')).toThrow();
-    });
-
-    it('should mention RedirectType usage in implementation', () => {
-      const redirectFilePath = path.resolve(__dirname, '../utils/redirect.ts');
-      const content = fs.readFileSync(redirectFilePath, 'utf8');
-      expect(content.includes('RedirectType')).toBe(true);
-      expect(content.includes('nextRedirect(redirectUrl, type)')).toBe(true);
-      expect(content.includes('nextRedirect(redirectUrl)')).toBe(true);
-    });
-  });
-
-  describe('URL locale matcher regex behavior (simulated)', () => {
-    it('should match prefixes based on project strategy', () => {
-      const { defaultLocaleValue, locales, localeUrlStrategy } =
-        settings.localization;
-      const urlLocaleMatcherRegex = computeUrlLocaleMatcherRegex(settings);
-
-      const nonDefault = locales.find((l) => l.value !== defaultLocaleValue);
-
-      if (localeUrlStrategy === 'show-all-locales') {
-        expect(
-          urlLocaleMatcherRegex.test(`/${defaultLocaleValue}/profile`)
-        ).toBe(true);
-      } else {
-        expect(
-          urlLocaleMatcherRegex.test(`/${defaultLocaleValue}/profile`)
-        ).toBe(false);
-      }
-
-      if (nonDefault) {
-        expect(urlLocaleMatcherRegex.test(`/${nonDefault.value}/profile`)).toBe(
-          true
-        );
-      }
-      expect(urlLocaleMatcherRegex.test('/profile')).toBe(false);
-    });
-  });
-
-  it('should verify redirect utility file exists and has expected structure', () => {
-    const redirectFilePath = path.resolve(__dirname, '../utils/redirect.ts');
-    const redirectFileContent = fs.readFileSync(redirectFilePath, 'utf8');
-    expect(redirectFileContent.includes('export const redirect')).toBe(true);
-    expect(redirectFileContent.includes('getUrlPathWithLocale')).toBe(true);
-    expect(redirectFileContent.includes('callbackUrl')).toBe(true);
-  });
-});

package/api/image-proxy.ts

@@ -1,75 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-
-async function proxyImage(imageUrl: string) {
-  if (!imageUrl) {
-    return NextResponse.json(
-      { success: false, error: 'Missing url parameter' },
-      { status: 400 }
-    );
-  }
-
-  const imageResponse = await fetch(imageUrl);
-
-  if (!imageResponse.ok) {
-    return NextResponse.json(
-      { success: false, error: 'Failed to fetch image from URL' },
-      { status: 400 }
-    );
-  }
-
-  const imageBuffer = await imageResponse.arrayBuffer();
-  const base64Image = Buffer.from(imageBuffer).toString('base64');
-  const contentType = imageResponse.headers.get('content-type') || 'image/jpeg';
-
-  return { base64Image, contentType, imageBuffer };
-}
-
-export async function GET(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const imageUrl = searchParams.get('url');
-
-    const result = await proxyImage(imageUrl!);
-    if (result instanceof NextResponse) {
-      return result;
-    }
-
-    return new NextResponse(result.imageBuffer, {
-      status: 200,
-      headers: {
-        'Content-Type': result.contentType,
-        'Access-Control-Allow-Origin': '*',
-        'Cache-Control': 'public, max-age=3600'
-      }
-    });
-  } catch (error) {
-    console.error('Image proxy error:', error);
-    return NextResponse.json(
-      { success: false, error: 'Internal server error' },
-      { status: 500 }
-    );
-  }
-}
-
-export async function POST(request: NextRequest) {
-  try {
-    const body = await request.json();
-    const imageUrl = body.imageUrl;
-
-    const result = await proxyImage(imageUrl);
-    if (result instanceof NextResponse) {
-      return result;
-    }
-
-    return NextResponse.json({
-      success: true,
-      base64Image: `data:${result.contentType};base64,${result.base64Image}`
-    });
-  } catch (error) {
-    console.error('Image proxy POST error:', error);
-    return NextResponse.json(
-      { success: false, error: 'Internal server error' },
-      { status: 500 }
-    );
-  }
-}

package/api/similar-product-list.ts

@@ -1,84 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { cookies } from 'next/headers';
-import Settings from 'settings';
-import { ServerVariables } from '../utils/server-variables';
-
-export async function GET(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const dynamicFilter = request.headers.get('x-search-dynamic-filter');
-    const dynamicExclude = request.headers.get('x-search-dynamic-exclude');
-
-    const nextCookies = cookies();
-    const currency =
-      nextCookies.get('pz-currency')?.value || ServerVariables.currency;
-    const locale =
-      nextCookies.get('pz-locale')?.value || ServerVariables.locale;
-
-    if (!dynamicFilter && !dynamicExclude) {
-      return NextResponse.json(
-        {
-          error:
-            'Missing x-search-dynamic-filter or x-search-dynamic-exclude header'
-        },
-        { status: 400 }
-      );
-    }
-
-    if (Settings.commerceUrl === 'default') {
-      return NextResponse.json(
-        { error: 'Commerce URL is not configured' },
-        { status: 500 }
-      );
-    }
-
-    const queryString = searchParams.toString();
-    const apiUrl = `${Settings.commerceUrl}/list${
-      queryString ? `?${queryString}` : ''
-    }`;
-
-    const headers: Record<string, string> = {
-      Accept: 'application/json',
-      'Content-Type': 'application/json'
-    };
-
-    if (dynamicFilter) {
-      headers['x-search-dynamic-filter'] = dynamicFilter;
-    } else if (dynamicExclude) {
-      headers['x-search-dynamic-exclude'] = dynamicExclude;
-    }
-
-    if (currency) {
-      headers['x-currency'] = currency;
-    }
-
-    if (locale) {
-      const currentLocale = Settings.localization.locales.find(
-        (l) => l.value === locale
-      );
-      if (currentLocale) {
-        headers['Accept-Language'] = currentLocale.apiValue;
-      }
-    }
-
-    const response = await fetch(apiUrl, {
-      method: 'GET',
-      headers
-    });
-
-    if (!response.ok) {
-      return NextResponse.json(
-        { error: `API request failed with status: ${response.status}` },
-        { status: response.status }
-      );
-    }
-
-    const data = await response.json();
-    return NextResponse.json(data);
-  } catch (error) {
-    return NextResponse.json(
-      { error: (error as Error).message },
-      { status: 500 }
-    );
-  }
-}