@redneckz/wildless-cms-uni-blocks 0.2.111 → 0.2.112

package/mobile/src/ui-kit/TopItem/TopItem.tsx

@@ -0,0 +1,64 @@
+import { JSX } from '@redneckz/uni-jsx';
+import { BgColorVersion } from '../../model/BgColorVersion';
+import type { LinkProps } from '../../model/LinkProps';
+
+export interface TopItemContent extends LinkProps {
+  active?: boolean;
+}
+
+export interface TopItemProps extends TopItemContent {
+  className?: string;
+  flat?: boolean;
+  ariaLabel?: string;
+  onClick?: (ev: MouseEvent) => any;
+  bgColor?: BgColorVersion;
+}
+
+const TEXT_CLASSES = 'font-sans font-normal text-sm';
+const LINK_CLASSES = 'inline-block border border-solid bg-transparent text-center no-underline';
+
+export const TopItem = JSX<TopItemProps>(
+  ({
+    className = '',
+    text,
+    href,
+    target,
+    active,
+    flat,
+    onClick,
+    children,
+    ariaLabel,
+    bgColor = 'bg-white',
+  }) => (
+    <a
+      className={`${getLinkClasses(bgColor, active, flat)} ${className}`}
+      href={href}
+      target={target}
+      onClick={onClick}
+      rel="noopener noreferrer"
+      aria-label={ariaLabel}
+    >
+      <span className={getTextClasses(bgColor, active, flat)}>{text || children}</span>
+    </a>
+  ),
+);
+
+const getLinkClasses = (bgColor: BgColorVersion, active?: boolean, flat?: boolean) => {
+  let classes = 'border-transparent';
+  if (active) {
+    classes = `rounded-md ${bgColor === 'bg-white' ? 'border-primary-main' : 'border-white'}`;
+  }
+
+  return `${classes} ${LINK_CLASSES} ${flat ? '' : 'px-4 py-2'}`;
+};
+
+const getTextClasses = (bgColor: BgColorVersion, active?: boolean, flat?: boolean) => {
+  let classes = 'text-white';
+  if (bgColor === 'bg-white') {
+    classes = active
+      ? 'text-primary-main'
+      : `${flat ? 'text-primary-text' : 'text-secondary-text'} hover:text-primary-main`;
+  }
+
+  return `${classes} ${TEXT_CLASSES}`;
+};

package/mobile/src/utils/addSpacesBetweenNumbers.ts

@@ -0,0 +1,2 @@
+export const addSpacesBetweenNumbers = (number: number) =>
+  new Intl.NumberFormat('ru-RU', { maximumSignificantDigits: 3 }).format(number);

package/mobile/src/utils/adjustHref.spec.ts

@@ -0,0 +1,25 @@
+import { adjustHref } from './adjustHref';
+
+describe('adjustHref', () => {
+  it('should compute URL relative to some base URL', () => {
+    expect(
+      adjustHref('http://foo.ru/other/path', {
+        pathname: '/some/path',
+        href: 'http://foo.ru/some/path',
+      }),
+    ).toBe('/other/path');
+  });
+
+  it('should compute mobile URL for mobile pages', () => {
+    expect(
+      adjustHref('http://foo.ru/other/path', {
+        pathname: '/mobile/some/path',
+        href: 'http://foo.ru/mobile/some/path',
+      }),
+    ).toBe('/mobile/other/path');
+  });
+
+  it('should return nothing if nothing provided', () => {
+    expect(adjustHref(undefined, { pathname: '/mobile/some/path' })).toBe(undefined);
+  });
+});

package/mobile/src/utils/adjustHref.ts

@@ -0,0 +1,24 @@
+import { getOrigin, isURL } from './url';
+import { MOBILE_URL_PATH } from './withoutMobilePath';
+
+export const adjustHref = (
+  href: string | undefined,
+  router: { pathname: string; href?: string },
+) => {
+  if (!href) {
+    return href;
+  }
+
+  const relativeHref = toRelativeHref(href, router) || '';
+  const isMobilePage = router?.pathname.startsWith(MOBILE_URL_PATH);
+  return isMobilePage && !isURL(relativeHref) ? `${MOBILE_URL_PATH}${relativeHref}` : relativeHref;
+};
+
+const toRelativeHref = (href: string | undefined, router: { href?: string }) => {
+  if (!href) {
+    return href;
+  }
+
+  const origin = getOrigin(router?.href);
+  return origin ? href.replace(origin, '') || '/' : href;
+};

package/mobile/src/utils/clamp.ts

@@ -0,0 +1,2 @@
+export const clamp = (value: number, min: number, max: number) =>
+  Math.max(min, Math.min(value, max));

package/mobile/src/utils/getColSpan.ts

@@ -0,0 +1,5 @@
+export const getColSpan = (className: string) => {
+  const colSpanPrefix = 'col-span-';
+  const colSpanStr = className.split(/\s+/).find((_) => _.startsWith(colSpanPrefix));
+  return colSpanStr ? parseInt(colSpanStr.substring(colSpanPrefix.length), 10) : 12;
+};

package/mobile/src/utils/getGeolocation.ts

@@ -0,0 +1,4 @@
+export const getGeolocation = async () =>
+  new Promise<GeolocationCoordinates>((resolve) =>
+    navigator.geolocation.getCurrentPosition(({ coords }) => resolve(coords)),
+  );

package/mobile/src/utils/joinList.ts

@@ -0,0 +1,7 @@
+export function joinList<E>(sep: E): (list: E[]) => E[] {
+  return (list) =>
+    list.reduce(
+      (acc, el, i) => (acc.length ? acc.concat({ ...sep, key: i }, el) : [el]),
+      [] as E[],
+    );
+}

package/mobile/src/utils/maxBy.spec.ts

@@ -0,0 +1,11 @@
+import { maxBy } from './maxBy';
+
+describe('maxBy', () => {
+  it('should return max value', () => {
+    expect(maxBy((_: number) => _)([1, 3, 2])).toBe(3);
+  });
+
+  it('should return max value with respect to discriminator', () => {
+    expect(maxBy((_: string) => _.length)(['123', '123456789', '123456'])).toBe('123456789');
+  });
+});

package/mobile/src/utils/maxBy.ts

@@ -0,0 +1,7 @@
+export const maxBy =
+  <Item, Value>(discriminator: (item: Item) => Value) =>
+  (list: Item[]): Item =>
+    list.reduceRight((a, b) => (discriminator(a) > discriminator(b) ? a : b));
+
+export const minBy = <Item, Value>(discriminator: (item: Item) => Value) =>
+  maxBy((_: Item) => -discriminator(_));

package/mobile/src/utils/url.spec.ts

@@ -0,0 +1,17 @@
+import { getOrigin, withoutQuery } from './url';
+
+describe('url', () => {
+  describe('withoutQuery', () => {
+    it('should return URL without query params', () => {
+      expect(withoutQuery('http://foo.ru/other/path?first=1&second=2')).toBe(
+        'http://foo.ru/other/path',
+      );
+    });
+  });
+
+  describe('getOrigin', () => {
+    it('should return origin of specified URL', () => {
+      expect(getOrigin('http://foo.ru/other/path?first=1&second=2')).toBe('http://foo.ru');
+    });
+  });
+});

package/mobile/src/utils/url.ts

@@ -0,0 +1,15 @@
+export const isURL = (href?: string) => href?.includes('//');
+
+export const withoutQuery = (href?: string) => (href || '').replace(/\/?\?.*/, '');
+
+export const getOrigin = (href?: string) => {
+  if (!href || !isURL(href)) {
+    return undefined;
+  }
+
+  const url = href;
+  const protoSeparator = '//';
+  const endOfProto = url.indexOf(protoSeparator);
+  const endOfOrigin = url.indexOf('/', endOfProto + protoSeparator.length);
+  return endOfOrigin !== -1 ? url.substring(0, endOfOrigin) : url;
+};

package/mobile/src/utils/withoutMobilePath.ts

@@ -0,0 +1,3 @@
+export const MOBILE_URL_PATH = '/mobile';
+
+export const withoutMobilePath = (href?: string) => (href || '').replace(MOBILE_URL_PATH, '');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redneckz/wildless-cms-uni-blocks",
-  "version": "0.2.111",
+  "version": "0.2.112",
   "private": false,
   "license": "MIT",
   "author": "ЦК",