bmdl-sdk 1.5.9 → 2.0.1

package/src/types/general.type.ts

@@ -0,0 +1,86 @@
+export interface IWindowSize {
+	width?: number
+	height?: number
+}
+
+/////
+
+export interface IColumnItem {
+	key: string
+	title: string
+	sort?: string
+}
+
+/////
+
+export type SortType = 'asc' | 'desc' | false
+
+export interface ISortItem {
+	column: string
+	order: SortType
+}
+
+/////
+
+export interface IDataQuery {
+	q?: string
+	sort?: string
+	filter?: string
+	page?: string
+	limit?: string
+}
+
+export interface IGetDataOptions {
+	q?: string
+	sort?: ISortItem[]
+	filter?: Record<string, any>
+	page?: number
+	limit?: number
+}
+
+/////
+
+export interface IPaginationOptions {
+	page: number
+	limit: number
+	pages: number
+	total: number
+}
+
+export interface IPagination extends IPaginationOptions {
+	hasPrevPage: boolean
+	hasNextPage: boolean
+	pageNumbers: (number | 'ellipsis')[]
+}
+
+/////
+
+export interface IFilterQuery {
+	querykey: string
+	queryFn: (params: any) => any
+}
+
+/////
+
+export type TranslateFn = (
+	key: string,
+	values?: Record<string, string | number | Date>
+) => string
+
+/////
+
+export enum AccessType {
+	VIEW = 'view',
+	EDIT = 'edit',
+	ALL = 'all'
+}
+
+interface IGuardItem {
+	id: number
+	type: AccessType
+}
+
+export interface IGuard {
+	users: IGuardItem[]
+	groups: IGuardItem[]
+}

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from './general.type'
+//
+export type { ComponentsTableDataItem } from './component.type'
+export type { DatasetsTableDataItem, DatasetType } from './dataset.type'
+export type { IDatasetFileInfo, IFileInfo } from './file.type'
+export type { BreakpointType, GridSizeType, LayoutsType } from './layer.type'
+export type { ProjectData, ProjectsTableDataItem } from './project.type'
+export type { UsersTableDataItem } from './user.type'
+export type { WidgetsTableDataItem } from './widget.type'

package/src/types/layer.type.ts

@@ -0,0 +1,7 @@
+import { Layout } from 'react-grid-layout'
+
+export type BreakpointType = 'lg' | 'md' | 'sm' | 'xs' | 'xxs'
+
+export type LayoutsType = Partial<Record<BreakpointType, Layout>>
+
+export type GridSizeType = BreakpointType | 'full'

package/src/types/project.type.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react'
+
+import { ProjectModel, ThemeModel } from '@/graphql'
+
+export type ProjectData = Pick<
+	ProjectModel,
+	'id' | 'name' | 'previewPath' | 'icon' | 'layers'
+> & {
+	theme: Pick<ThemeModel, 'options'>
+}
+
+export type ProjectsTableDataItem = Record<
+	'icon' | 'name' | 'description' | 'author' | 'createdAt' | 'editedAt',
+	ReactNode
+>

package/src/types/user.type.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react'
+
+export type UsersTableDataItem = Record<
+	'profile' | 'username' | 'email' | 'createdAt' | 'editedAt',
+	ReactNode
+>

package/src/types/widget.type.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react'
+
+export type WidgetsTableDataItem = Record<
+	| 'icon'
+	| 'name'
+	| 'description'
+	| 'connects'
+	| 'author'
+	| 'createdAt'
+	| 'editedAt',
+	ReactNode
+>

package/src/utils/bm.util.ts

@@ -0,0 +1,150 @@
+export const _ = {
+	/**
+	 * Проверяет является ли значение булевым
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isBoolean(value: unknown): value is boolean {
+		return typeof value === 'boolean'
+	},
+	/**
+	 * Проверяет является ли значение null
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isNull(value: unknown): value is null {
+		return value === null
+	},
+	/**
+	 * Проверяет является ли значение undefined
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isUndefined(value: unknown): value is undefined {
+		return value === undefined
+	},
+	/**
+	 * Проверяет является ли значение строкой
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isString(value: unknown): value is string {
+		return typeof value === 'string'
+	},
+	/**
+	 * Проверяет является ли значение числом
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isNumber(value: unknown): value is number {
+		return typeof value === 'number'
+	},
+	/**
+	 * Проверяет является ли значение датой
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isDate(value: unknown): value is Date {
+		return value instanceof Date
+	},
+	/**
+	 * Проверяет является ли значение массивом
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isArray(value: unknown): value is Array<unknown> {
+		return Array.isArray(value)
+	},
+	/**
+	 * Проверяет является ли значение объектом
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isObject(value: unknown): value is Record<string, unknown> {
+		return (
+			typeof value === 'object' &&
+			!this.isNull(value) &&
+			!this.isArray(value) &&
+			!this.isDate(value) &&
+			!(value instanceof RegExp) &&
+			!(value instanceof Map) &&
+			!(value instanceof Set)
+		)
+	},
+	//////////////////////////////
+	/**
+	 * Проверка на пустое значение (null, undefined, '', [], {})
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	isEmpty(value: unknown) {
+		if (this.isNull(value) || this.isUndefined(value)) return true
+		if (this.isString(value) || this.isArray(value)) {
+			return value.length === 0
+		}
+		if (this.isObject(value)) {
+			return Object.keys(value).length === 0
+		}
+		return false
+	},
+	//////////////////////////////
+	/**
+	 * Приведение значения к булевому значению
+	 * @param {unknown} value
+	 * @returns {boolean}
+	 */
+	toBoolean(value: unknown): boolean {
+		if (this.isString(value)) {
+			const lowerValue = value.trim().toLowerCase()
+			if (lowerValue === 'true') {
+				return true
+			}
+			if (lowerValue === 'false') {
+				return false
+			}
+		}
+
+		return Boolean(value)
+	},
+	/**
+	 * Приведение значения к числу
+	 * @param {unknown} value
+	 * @returns {number}
+	 */
+	toNumber(value: unknown): number {
+		if (this.isString(value)) {
+			const trimmedValue = value.trim()
+
+			if (trimmedValue === '') {
+				return 0
+			}
+
+			const num = Number(trimmedValue)
+
+			if (!isNaN(num) && isFinite(num)) {
+				return num
+			}
+
+			const lowerValue = trimmedValue.toLowerCase()
+			if (lowerValue === 'true') {
+				return 1
+			}
+			if (lowerValue === 'false') {
+				return 0
+			}
+
+			return 0
+		}
+
+		if (this.isNull(value) || this.isUndefined(value) || value === false) {
+			return 0
+		}
+
+		if (value === true) {
+			return 1
+		}
+
+		const num = Number(value)
+		return isNaN(num) || !isFinite(num) ? 0 : num
+	}
+}

package/src/utils/bytes.util.ts

@@ -0,0 +1,110 @@
+const b = 1
+const kb = b * 1024
+const mb = kb * 1024
+const gb = mb * 1024
+const tb = gb * 1024
+const pb = tb * 1024
+
+type SizeUnit =
+	| 'Bytes'
+	| 'Byte'
+	| 'B'
+	| 'Kilobytes'
+	| 'Kilobyte'
+	| 'Kb'
+	| 'KB'
+	| 'K'
+	| 'Megabytes'
+	| 'Megabyte'
+	| 'Mb'
+	| 'MB'
+	| 'M'
+	| 'Gigabytes'
+	| 'Gigabyte'
+	| 'Gb'
+	| 'GB'
+	| 'G'
+	| 'Terabytes'
+	| 'Terabyte'
+	| 'Tb'
+	| 'TB'
+	| 'T'
+	| 'Petabytes'
+	| 'Petabyte'
+	| 'Pb'
+	| 'PB'
+	| 'P'
+
+type SizeUnitAnyCase = SizeUnit | Uppercase<SizeUnit> | Lowercase<SizeUnit>
+
+export type SizeStringValue =
+	| `${number}`
+	| `${number}${SizeUnitAnyCase}`
+	| `${number} ${SizeUnitAnyCase}`
+
+/**
+ * Парсит строку с размером файла и возвращает размер в байтах
+ * @param str - строка с размером, например '2GB', '1.5 MB', '512kb', '1024'
+ * @returns размер в байтах
+ * 
+ * @example
+ * bytes('2GB') // вернет 2147483648
+ * bytes('1.5 MB') // вернет 1572864
+ * bytes('512kb') // вернет 524288
+ * bytes('1024') // вернет 1024 (байты по умолчанию)
+ */
+export const bytes = (str: SizeStringValue): number => {
+	if (typeof str !== 'string' || str.length === 0 || str.length > 100) {
+		throw new Error(
+			'Value provided to bytes() must be a string with length between 1 and 99.'
+		)
+	}
+
+	const match =
+		/^(?<value>-?(?:\d+)?\.?\d+) *(?<type>bytes?|b|kilobytes?|kb|k|megabytes?|mb|m|gigabytes?|gb|g|terabytes?|tb|t|petabytes?|pb|p)?$/i.exec(
+			str
+		)
+
+	const groups = match?.groups as { value: string; type?: string } | undefined
+	if (!groups) {
+		return NaN
+	}
+	const n = parseFloat(groups.value)
+	const type = (groups.type || 'b').toLowerCase() as Lowercase<SizeUnit>
+
+	switch (type) {
+		case 'petabytes':
+		case 'petabyte':
+		case 'pb':
+		case 'p':
+			return n * pb
+		case 'terabytes':
+		case 'terabyte':
+		case 'tb':
+		case 't':
+			return n * tb
+		case 'gigabytes':
+		case 'gigabyte':
+		case 'gb':
+		case 'g':
+			return n * gb
+		case 'megabytes':
+		case 'megabyte':
+		case 'mb':
+		case 'm':
+			return n * mb
+		case 'kilobytes':
+		case 'kilobyte':
+		case 'kb':
+		case 'k':
+			return n * kb
+		case 'bytes':
+		case 'byte':
+		case 'b':
+			return n
+		default:
+			throw new Error(
+				`Error: size unit ${type} was recognized but does not have a corresponding case. Please check the input.`
+			)
+	}
+}

package/src/utils/date.util.ts

@@ -0,0 +1,49 @@
+import dayjs from 'dayjs'
+import 'dayjs/locale/ru'
+import relativeTime from 'dayjs/plugin/relativeTime'
+import updateLocale from 'dayjs/plugin/updateLocale'
+
+dayjs.extend(relativeTime)
+dayjs.extend(updateLocale)
+
+dayjs.locale('ru')
+
+dayjs.updateLocale('ru', {
+	relativeTime: {
+		past: '%s назад',
+		s: 'несколько секунд',
+		m: '1 минута',
+		mm: '%d минут',
+		h: '1 час',
+		hh: '%d часов',
+		d: '1 день',
+		dd: '%d дней'
+	}
+})
+
+export function isWeekPassed(fromDate: string | number | Date): boolean {
+	const startDate = dayjs(fromDate)
+	const dateAfter7Days = startDate.add(7, 'day')
+	return dayjs().isAfter(dateAfter7Days)
+}
+
+export function fromNow(fromDate: string | number | Date): string {
+	return dayjs(fromDate).fromNow()
+}
+
+export function getFormatDate(
+	date: string | number | Date,
+	locale: string
+): string {
+	const getDateFormat = (locale: string) => {
+		switch (locale) {
+			case 'en':
+				return 'MM/DD/YYYY, hh:mm A'
+			case 'ru':
+			default:
+				return 'DD.MM.YYYY, HH:mm'
+		}
+	}
+
+	return dayjs(date).format(getDateFormat(locale))
+}

package/src/utils/dynamicMessage.util.ts

@@ -0,0 +1,9 @@
+import { TranslateFn } from '@/types'
+
+export function dynamicMessage(message: string, te: TranslateFn): string {
+	const isDynamicText = message.includes('|')
+	const [text, variable] = message.split('|')
+	const [key, value] = (variable || '').split('=')
+
+	return isDynamicText ? te(text, { [key]: value }) : te(message)
+}

package/src/utils/getInitials.util.ts

@@ -0,0 +1,10 @@
+export function getInitials(fio: string): string {
+	return fio
+		.split(' ')
+		.map((item, index) => {
+			if (index > 1) return ''
+			//
+			return item[0]
+		})
+		.join('')
+}

package/src/utils/hideEmail.util.ts

@@ -0,0 +1,14 @@
+export function hideEmail(value?: string): string {
+	const email = value?.includes('@') ? value : ''
+
+	if (!email) return '*****@*****'
+
+	return email
+		.split('@')
+		.map((item, index) => {
+			if (index) return item
+			//
+			return item[0] + '*****'
+		})
+		.join('@')
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export { _ } from './bm.util'
+export { bytes, type SizeStringValue } from './bytes.util'
+export { fromNow, getFormatDate, isWeekPassed } from './date.util'
+export { dynamicMessage } from './dynamicMessage.util'
+export { getInitials } from './getInitials.util'
+export { hideEmail } from './hideEmail.util'
+export { getPaginationData, getRangePagination } from './pagination.util'
+export { twJoin } from './twJoin.util'
+export { twMerge } from './twMerge.util'
+export { formatFileSize, getAcceptedTypesText } from './upload.util'
+export { addParam, getParam, getParams, removeParam } from './url.util'
+

package/src/utils/pagination.util.ts

@@ -0,0 +1,144 @@
+import { IPagination, IPaginationOptions } from '@/types'
+
+export function getPaginationData(pagination: IPaginationOptions): IPagination {
+	const { limit, page, pages, total } = pagination
+
+	const hasPrevPage = page > 0
+	const hasNextPage = page < pages - 1
+
+	const pageNumbers = generatePageNumbers(page, pages)
+
+	return {
+		limit,
+		page,
+		pages,
+		total,
+		hasPrevPage,
+		hasNextPage,
+		pageNumbers
+	}
+}
+
+////////////
+
+function generatePageNumbers(
+	currentPage: number,
+	totalPages: number
+): (number | 'ellipsis')[] {
+	if (totalPages <= 7) {
+		return Array.from({ length: totalPages }, (_, i) => i + 1)
+	}
+
+	const result: (number | 'ellipsis')[] = []
+
+	result.push(1)
+
+	if (totalPages === 8) {
+		if (currentPage < 4) {
+			result.push(2, 3, 4, 5)
+			result.push('ellipsis')
+			result.push(8)
+		} else {
+			result.push('ellipsis')
+			result.push(4, 5, 6, 7, 8)
+		}
+		return result
+	}
+
+	if (totalPages === 9) {
+		if (currentPage <= 4) {
+			result.push(2, 3, 4, 5)
+			result.push('ellipsis')
+			result.push(9)
+		} else if (currentPage === 5) {
+			result.push('ellipsis', 3, 4, 5, 6, 7, 'ellipsis', 9)
+		} else {
+			result.push('ellipsis')
+			result.push(5, 6, 7, 8, 9)
+		}
+		return result
+	}
+
+	if (totalPages === 10) {
+		if (currentPage <= 4) {
+			result.push(2, 3, 4, 5)
+			result.push('ellipsis')
+			result.push(10)
+		} else if (currentPage === 5) {
+			result.push('ellipsis', 3, 4, 5, 6, 7, 'ellipsis', 10)
+		} else if (currentPage === 6) {
+			result.push('ellipsis', 4, 5, 6, 7, 8, 'ellipsis', 10)
+		} else {
+			result.push('ellipsis')
+			result.push(6, 7, 8, 9, 10)
+		}
+		return result
+	}
+
+	if (totalPages === 11) {
+		if (currentPage <= 4) {
+			result.push(2, 3, 4, 5)
+			result.push('ellipsis')
+			result.push(11)
+		} else if (currentPage >= 5 && currentPage <= 7) {
+			result.push('ellipsis')
+			result.push(
+				currentPage - 2,
+				currentPage - 1,
+				currentPage,
+				currentPage + 1,
+				currentPage + 2
+			)
+			result.push('ellipsis')
+			result.push(11)
+		} else {
+			result.push('ellipsis')
+			result.push(7, 8, 9, 10, 11)
+		}
+		return result
+	}
+
+	if (currentPage <= 4) {
+		result.push(2, 3, 4, 5)
+		result.push('ellipsis')
+		result.push(totalPages)
+	} else if (currentPage >= totalPages - 3) {
+		result.push('ellipsis')
+		result.push(
+			totalPages - 4,
+			totalPages - 3,
+			totalPages - 2,
+			totalPages - 1,
+			totalPages
+		)
+	} else {
+		result.push('ellipsis')
+		result.push(
+			currentPage - 2,
+			currentPage - 1,
+			currentPage,
+			currentPage + 1,
+			currentPage + 2
+		)
+		result.push('ellipsis')
+		result.push(totalPages)
+	}
+
+	return result
+}
+
+////////////
+
+export function getRangePagination(
+	pagination: IPaginationOptions
+): Record<string, number> {
+	const { page, limit, total } = pagination
+	//
+	const startIndex = page * limit
+	const endIndex = Math.min((page + 1) * limit, total)
+	//
+	return {
+		from: startIndex + 1,
+		to: endIndex
+	}
+}

package/src/utils/twJoin.util.ts

@@ -0,0 +1,49 @@
+import { _ } from './bm.util'
+
+interface IBaseStyles {
+	mouse?: string | string[]
+	position?: string | string[]
+	display?: string | string[]
+	text?: string | string[]
+	visual?: string | string[]
+	transform?: string | string[]
+	animation?: string | string[]
+}
+
+interface IExtraStyles {
+	hover?: string | string[] | (IBaseStyles & IExtraStyles)
+	focus?: string | string[] | (IBaseStyles & IExtraStyles)
+	active?: string | string[] | (IBaseStyles & IExtraStyles)
+	disabled?: string | string[] | (IBaseStyles & IExtraStyles)
+	placeholder?: string | string[] | (IBaseStyles & IExtraStyles)
+	attrs?: string | string[] | (IBaseStyles & IExtraStyles)
+	childs?: string | string[] | (IBaseStyles & IExtraStyles)
+	adaptive?: string | string[] | (IBaseStyles & IExtraStyles)
+	dark?: string | string[] | (IBaseStyles & IExtraStyles)
+	after?: string | string[] | (IBaseStyles & IExtraStyles)
+}
+
+interface ITwJoin extends IBaseStyles, IExtraStyles {
+	tw?: string | string[]
+	vars?: string | string[]
+}
+
+const stylesFlat = (styles: ITwJoin): string[] => {
+	if (_.isObject(styles)) {
+		return (Object.values(styles) as ITwJoin[]).flatMap(stylesFlat)
+	}
+	//
+	if (_.isArray(styles)) {
+		return styles as string[]
+	}
+	//
+	if (_.isString(styles)) {
+		return [styles]
+	}
+	//
+	return []
+}
+
+export function twJoin(styles: ITwJoin): string {
+	return Object.values(styles).flatMap(stylesFlat).filter(Boolean).join(' ')
+}

package/src/utils/twMerge.util.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge as merge } from 'tailwind-merge'
+
+export function twMerge(...inputs: ClassValue[]) {
+	return merge(clsx(inputs))
+}