@akinon/next 1.0.0

package/utils/get-currency.ts

@@ -0,0 +1,29 @@
+'use client'
+
+import getSymbolFromCurrency from 'currency-symbol-map';
+
+type GetCurrencyType = {
+  currencyCode: string;
+  useCurrencySymbol?: boolean;
+  useCurrencyAfterPrice?: boolean;
+  useCurrencySpace?: boolean;
+};
+
+export const getCurrency = (args: GetCurrencyType) => {
+  const {
+    currencyCode,
+    useCurrencySymbol = true,
+    useCurrencyAfterPrice = true,
+    useCurrencySpace = true
+  } = args;
+
+  const currencySpace = useCurrencySpace ? ' ' : '';
+  const currency = useCurrencySymbol
+    ? `${getSymbolFromCurrency(currencyCode)}`
+    : currencyCode;
+  const currencyAfterPrice = useCurrencyAfterPrice
+    ? `${currencySpace}${currency}`
+    : `${currency}${currencySpace}`;
+
+  return currencyAfterPrice;
+};

package/utils/image-loader.ts

@@ -0,0 +1,31 @@
+import { buildCDNUrl } from '.';
+import { CDNOptions } from '../types';
+
+export interface ImageLoaderParams {
+  src: string;
+  width: number;
+  quality: number;
+  crop: CDNOptions['crop'];
+  fill?: boolean;
+  aspectRatio?: number;
+}
+
+export const ImageLoader = ({
+  src,
+  width,
+  quality,
+  crop,
+  fill,
+  aspectRatio
+}: ImageLoaderParams) => {
+  if (src.match(/akinoncdn|akinoncloud|b-cdn\.net/)) {
+    return buildCDNUrl(src, {
+      width,
+      height: fill ? parseInt(String(Number(width) / aspectRatio)) : undefined,
+      quality,
+      crop
+    });
+  }
+
+  return src;
+};

package/utils/index.ts

@@ -0,0 +1,132 @@
+import settings from 'settings';
+import { LocaleUrlStrategy } from '../localization';
+import { CDNOptions, ClientRequestOptions } from '../types';
+
+export * from './get-currency';
+export * from './menu-generator';
+export * from './generate-commerce-search-params';
+
+export function getCookie(name: string) {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+
+  if (parts.length === 2) {
+    return parts.pop().split(';').shift();
+  }
+}
+
+export function setCookie(name: string, val: string) {
+  const date = new Date();
+  const value = val;
+
+  date.setTime(date.getTime() + 7 * 24 * 60 * 60 * 1000);
+
+  document.cookie =
+    name + '=' + value + '; expires=' + date.toUTCString() + '; path=/';
+}
+
+export function removeCookie(name: string) {
+  const date = 'Thu, 01 Jan 1970 00:00:00 UTC';
+
+  document.cookie = name + '=' + '; expires=' + date + '; path=/';
+}
+
+export function setCurrency(currency: string) {
+  setCookie('pz-currency', currency);
+}
+
+export function getTranslateFn(path: string, translations: any) {
+  const get = (parts_: Array<string>, tObj: any) => {
+    const currentPart = parts_[0];
+
+    if (parts_.length === 1) {
+      return tObj?.[currentPart] ?? path;
+    }
+
+    return get(parts_.slice(1), tObj?.[currentPart]);
+  };
+
+  return get(path.split('.'), translations);
+}
+
+export function buildClientRequestUrl(
+  path: string,
+  options?: ClientRequestOptions
+) {
+  let url = `/api/client${path}`;
+
+  if (options) {
+    if (url.includes('?')) {
+      url += '&';
+    } else {
+      url += '?';
+    }
+
+    url += `options=${encodeURIComponent(JSON.stringify(options))}`;
+  }
+
+  return url;
+}
+
+export function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function asTypedObject<E>() {
+  return function <T>(et: { [K in keyof T]: E }) {
+    return et;
+  };
+}
+
+function splitUrlByFileExtension(path: string) {
+  const lastDotIndex = path.lastIndexOf('.');
+  return [path.slice(0, lastDotIndex), path.slice(lastDotIndex)] as const;
+}
+
+export function buildCDNUrl(url: string, config?: CDNOptions) {
+  const [root, fileExtension] = splitUrlByFileExtension(url);
+
+  let options = '';
+
+  if (config) {
+    const { width, height, quality, crop, upscale } = config;
+
+    if (width && height) {
+      options += `_size${width}x${height}`;
+    } else if (height) {
+      options += `_sizex${height}`;
+    } else if (width) {
+      options += `_size${width}`;
+    }
+
+    if (quality) {
+      options += `_quality${quality}`;
+    }
+
+    if (crop) {
+      options += `_crop${capitalize(crop)}`;
+    }
+
+    if (upscale) {
+      options += `_upscale${upscale.toString()}`;
+    }
+  }
+
+  return `${root}${options}${fileExtension}`;
+}
+
+export const urlLocaleMatcherRegex = new RegExp(
+  `^/(${settings.localization.locales
+    .filter((l) =>
+      settings.localization.localeUrlStrategy !==
+      LocaleUrlStrategy.ShowAllLocales
+        ? l.value !== settings.localization.defaultLocaleValue
+        : l
+    )
+    .map((l) => l.value)
+    .join('|')})`
+);

package/utils/localization.ts

@@ -0,0 +1,29 @@
+import settings from 'settings';
+import { LocaleUrlStrategy } from '../localization';
+
+export const getUrlPathWithLocale = (
+  pathname: string,
+  currentLocale?: string
+) => {
+  const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
+
+  if (!currentLocale) {
+    currentLocale = defaultLocaleValue;
+  }
+
+  if (localeUrlStrategy === LocaleUrlStrategy.HideAllLocales) {
+    return pathname;
+  }
+
+  if (localeUrlStrategy === LocaleUrlStrategy.HideDefaultLocale) {
+    if (currentLocale === defaultLocaleValue) {
+      return pathname;
+    } else {
+      return `/${currentLocale}${pathname}`;
+    }
+  }
+
+  if (localeUrlStrategy === LocaleUrlStrategy.ShowAllLocales) {
+    return `/${currentLocale}${pathname}`;
+  }
+};

package/utils/log.ts

@@ -0,0 +1,138 @@
+enum LogLevel {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  FATAL = 'fatal',
+  SILENT = 'silent'
+}
+
+const LOG_LEVELS = new Map([
+  ['trace', 10],
+  ['debug', 20],
+  ['info', 30],
+  ['warn', 40],
+  ['error', 50],
+  ['fatal', 60],
+  ['silent', 1000]
+]);
+
+interface LoggerFn {
+  (message: string, payload?: any): void;
+}
+
+interface Message {
+  message: string;
+  level?: LogLevel;
+  payload?: any;
+  details?: any;
+}
+
+const LOG_COLORS = new Map([
+  [LogLevel.TRACE, '\x1b[45m'],
+  [LogLevel.DEBUG, '\x1b[44m'],
+  [LogLevel.INFO, '\x1b[42m'],
+  [LogLevel.WARN, '\x1b[43m'],
+  [LogLevel.ERROR, '\x1b[41m'],
+  [LogLevel.FATAL, '\x1b[41m']
+]);
+
+let LOG_LEVEL = LOG_LEVELS.get(LogLevel.INFO);
+
+if (process.env.NODE_ENV === 'development') {
+  LOG_LEVEL = LOG_LEVELS.get(process.env.LOG_LEVEL_DEV ?? LogLevel.INFO);
+}
+
+if (process.env.NODE_ENV === 'production') {
+  LOG_LEVEL = LOG_LEVELS.get(process.env.LOG_LEVEL ?? LogLevel.INFO);
+}
+
+const writeMsg = ({ level, message, payload }: Message) => {
+  if (LOG_LEVELS.get(level) < LOG_LEVEL) {
+    return;
+  }
+
+  let log: Message | string = { message };
+
+  if (payload) {
+    log.details = payload;
+  }
+
+  if (process.env.NODE_ENV === 'production') {
+    log.level = level;
+    log = `PZ LOG    ----${level.toUpperCase()}----    ${JSON.stringify(log)}`;
+  }
+
+  if (process.env.NODE_ENV === 'development') {
+    console.log(
+      '\n\n' + LOG_COLORS.get(level),
+      `▼ PZ ${level.toUpperCase()}${
+        message.length < 250 ? ` ━━ ${message}` : ''
+      } \x1b[0m\n`,
+      log,
+      '\n\n'
+    );
+  } else {
+    console.log(log);
+  }
+};
+
+const info: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.INFO,
+    message,
+    payload
+  });
+};
+
+const error: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.ERROR,
+    message,
+    payload
+  });
+};
+
+const warn: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.WARN,
+    message,
+    payload
+  });
+};
+
+const debug: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.DEBUG,
+    message,
+    payload
+  });
+};
+
+const trace: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.TRACE,
+    message,
+    payload
+  });
+};
+
+const fatal: LoggerFn = (message, payload) => {
+  writeMsg({
+    level: LogLevel.FATAL,
+    message,
+    payload
+  });
+};
+
+const logger = {
+  trace,
+  debug,
+  info,
+  warn,
+  error,
+  fatal
+};
+
+export default logger;

package/utils/menu-generator.ts

@@ -0,0 +1,27 @@
+import { MenuItemType } from '../types';
+import logger from './log';
+
+export const menuGenerator = (arr: MenuItemType[]) => {
+  const tree: MenuItemType[] = [];
+
+  try {
+    const data: { [key: string]: MenuItemType } = {};
+
+    arr.forEach((item) => {
+      const newData = { ...item, children: [] };
+      data[item.pk] = newData;
+    });
+
+    Object.values(data).forEach((item) => {
+      if (item.parent) {
+        data[item.parent.pk].children.push(item);
+      } else {
+        tree.push(item);
+      }
+    });
+  } catch (error) {
+    logger.error(error, 'menuGenerator');
+  }
+
+  return tree;
+};

package/utils/mobile-3d-iframe.ts

@@ -0,0 +1,58 @@
+const iframeURLChange = (iframe, callback) => {
+  iframe.addEventListener('load', () => {
+    setTimeout(() => {
+      if (iframe?.contentWindow?.location) {
+        callback(iframe.contentWindow.location);
+      }
+    }, 0);
+  });
+};
+
+const removeIframe = async () => {
+  const iframeSelector = document.querySelector(
+    '.checkout-payment-iframe-wrapper'
+  );
+
+  if (!iframeSelector) {
+    return;
+  }
+
+  iframeSelector.remove();
+};
+
+export const showMobile3dIframe = (redirectUrl: string) => {
+  const iframeWrapper = document.createElement('div');
+  const iframe = document.createElement('iframe');
+  const closeButton = document.createElement('div');
+
+  iframeWrapper.className = 'checkout-payment-iframe-wrapper';
+  closeButton.className = 'close-button';
+  iframe.setAttribute('src', redirectUrl);
+  closeButton.innerHTML = '&#x2715';
+  closeButton.addEventListener('click', removeIframe);
+
+  iframeWrapper.append(iframe, closeButton);
+  document.body.appendChild(iframeWrapper);
+
+  iframeURLChange(iframe, (location) => {
+    if (location.origin !== window.location.origin) {
+      return false;
+    }
+
+    const searchParams = new URLSearchParams(location.search);
+    const isOrderCompleted = location.href.includes('/orders/completed');
+    const data = {
+      url: location.pathname
+    };
+
+    if (searchParams.has('success') || isOrderCompleted) {
+      removeIframe();
+    }
+
+    if (isOrderCompleted) {
+      (window.parent as any)?.ReactNativeWebView?.postMessage?.(
+        JSON.stringify(data)
+      );
+    }
+  });
+};

package/utils/server-translation.ts

@@ -0,0 +1,57 @@
+import 'server-only';
+import path from 'path';
+import fs from 'fs';
+import { getTranslateFn } from '../utils';
+import { Translations } from '../types';
+import settings from 'settings';
+import logger from './log';
+
+export const translations: Translations = {};
+
+// TODO: Read translations from cache
+export async function getTranslations(locale_: string) {
+  try {
+    const locale = settings.localization.locales.find(
+      (locale) => locale.value === locale_
+    );
+    const localeDirPath = path.resolve(
+      `public/locales/${locale.localePath ?? locale.value}`
+    );
+    const fileNames = fs.readdirSync(localeDirPath);
+
+    const fileImports = fileNames.map(
+      (fileName) =>
+        new Promise<string>((resolve, reject) => {
+          fs.readFile(
+            path.join(localeDirPath, `/${fileName}`),
+            'utf-8',
+            (error, data) => {
+              if (error) {
+                console.error(error);
+                reject(error.message);
+              }
+
+              resolve(data);
+            }
+          );
+        })
+    );
+
+    let index = 0;
+
+    for await (const fileImport of fileImports) {
+      translations[
+        fileNames[index].substring(0, fileNames[index].lastIndexOf('.'))
+      ] = JSON.parse(fileImport);
+      index++;
+    }
+  } catch (error) {
+    logger.error('Failed to read translations', error);
+  }
+
+  return translations;
+}
+
+export function t(path: string) {
+  return getTranslateFn(path, translations);
+}

package/utils/server-variables.ts

@@ -0,0 +1,9 @@
+import settings from 'settings';
+
+const { locales, defaultLocaleValue, defaultCurrencyCode } =
+  settings.localization;
+
+export const ServerVariables = {
+  locale: locales.find((l) => l.value === defaultLocaleValue)?.value ?? '',
+  currency: defaultCurrencyCode
+};