229 lines
7.1 KiB
TypeScript
229 lines
7.1 KiB
TypeScript
import { IconName, IconSrc } from '../components/icons';
|
|
|
|
export const bytesToSize = (bytes: number): string => {
|
|
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
|
|
if (bytes === 0) return '0KB';
|
|
|
|
let sizeIndex = Math.floor(Math.log(bytes) / Math.log(1000));
|
|
|
|
if (sizeIndex === 0) sizeIndex = 1;
|
|
|
|
return `${(bytes / 1000 ** sizeIndex).toFixed(1)} ${sizes[sizeIndex]}`;
|
|
};
|
|
|
|
export const millisecondsToMinutesAndSeconds = (milliseconds: number): string => {
|
|
const seconds = Math.floor(milliseconds / 1000);
|
|
const mm = Math.floor(seconds / 60);
|
|
const ss = Math.round(seconds % 60);
|
|
return `${mm}:${ss < 10 ? '0' : ''}${ss}`;
|
|
};
|
|
|
|
export const millisecondsToMinutes = (milliseconds: number): string => {
|
|
const seconds = Math.floor(milliseconds / 1000);
|
|
const mm = Math.floor(seconds / 60);
|
|
|
|
return mm.toString();
|
|
};
|
|
|
|
export const secondsToMinutesAndSeconds = (seconds: number): string => {
|
|
const mm = Math.floor(seconds / 60);
|
|
const ss = Math.round(seconds % 60);
|
|
return `${mm}:${ss < 10 ? '0' : ''}${ss}`;
|
|
};
|
|
|
|
export const getFileTypeIcon = (icons: Record<IconName, IconSrc>, fileType: string): IconSrc => {
|
|
const type = fileType.toLowerCase();
|
|
if (type.startsWith('audio')) {
|
|
return icons.Play;
|
|
}
|
|
if (type.startsWith('video')) {
|
|
return icons.Vlc;
|
|
}
|
|
if (type.startsWith('image')) {
|
|
return icons.Photo;
|
|
}
|
|
return icons.File;
|
|
};
|
|
|
|
export const fulfilledPromiseSettledResult = <T>(prs: PromiseSettledResult<T>[]): T[] =>
|
|
prs.reduce<T[]>((values, pr) => {
|
|
if (pr.status === 'fulfilled') values.push(pr.value);
|
|
return values;
|
|
}, []);
|
|
|
|
export const promiseFulfilledResult = <T>(
|
|
settledResult: PromiseSettledResult<T>,
|
|
): T | undefined => {
|
|
if (settledResult.status === 'fulfilled') return settledResult.value;
|
|
return undefined;
|
|
};
|
|
export const promiseRejectedResult = <T>(settledResult: PromiseSettledResult<T>): any => {
|
|
if (settledResult.status === 'rejected') return settledResult.reason;
|
|
return undefined;
|
|
};
|
|
|
|
export const binarySearch = <T>(items: T[], match: (item: T) => -1 | 0 | 1): T | undefined => {
|
|
const search = (start: number, end: number): T | undefined => {
|
|
if (start > end) return undefined;
|
|
|
|
const mid = Math.floor((start + end) / 2);
|
|
|
|
const result = match(items[mid]);
|
|
if (result === 0) return items[mid];
|
|
|
|
if (result === 1) return search(start, mid - 1);
|
|
return search(mid + 1, end);
|
|
};
|
|
|
|
return search(0, items.length - 1);
|
|
};
|
|
|
|
export const randomNumberBetween = (min: number, max: number) =>
|
|
Math.floor(Math.random() * (max - min + 1)) + min;
|
|
|
|
export const scaleYDimension = (x: number, scaledX: number, y: number): number => {
|
|
const scaleFactor = scaledX / x;
|
|
return scaleFactor * y;
|
|
};
|
|
|
|
/** Fit natural media size into a max box without upscaling. */
|
|
export const fitMediaSize = (
|
|
w: number,
|
|
h: number,
|
|
maxW: number,
|
|
maxH: number,
|
|
): { width: number; height: number } => {
|
|
if (w <= 0 || h <= 0) {
|
|
return { width: maxW, height: Math.round(maxW * 0.75) };
|
|
}
|
|
const scale = Math.min(maxW / w, maxH / h, 1);
|
|
return {
|
|
width: Math.max(1, Math.round(w * scale)),
|
|
height: Math.max(1, Math.round(h * scale)),
|
|
};
|
|
};
|
|
|
|
export const parseGeoUri = (location: string) => {
|
|
const [, data] = location.split(':');
|
|
const [cords] = data.split(';');
|
|
const [latitude, longitude] = cords.split(',');
|
|
return {
|
|
latitude,
|
|
longitude,
|
|
};
|
|
};
|
|
|
|
const START_SLASHES_REG = /^\/+/g;
|
|
const END_SLASHES_REG = /\/+$/g;
|
|
export const trimLeadingSlash = (str: string): string => str.replace(START_SLASHES_REG, '');
|
|
export const trimTrailingSlash = (str: string): string => str.replace(END_SLASHES_REG, '');
|
|
|
|
export const trimSlash = (str: string): string => trimLeadingSlash(trimTrailingSlash(str));
|
|
|
|
export const nameInitials = (str: string | undefined | null, len = 1): string => {
|
|
if (!str) return '�';
|
|
return [...str].slice(0, len).join('') || '�';
|
|
};
|
|
|
|
export const randomStr = (len = 12): string => {
|
|
let str = '';
|
|
const minCode = 'A'.charCodeAt(0);
|
|
const maxCode = 'Z'.charCodeAt(0);
|
|
|
|
for (let i = 0; i < len; i += 1) {
|
|
const code = Math.floor(Math.random() * (maxCode - minCode + 1) + minCode);
|
|
str += String.fromCharCode(code);
|
|
}
|
|
return str;
|
|
};
|
|
|
|
export const suffixRename = (name: string, validator: (newName: string) => boolean): string => {
|
|
let suffix = 1;
|
|
let newName;
|
|
do {
|
|
newName = name + suffix;
|
|
suffix += 1;
|
|
} while (validator(newName));
|
|
|
|
return newName;
|
|
};
|
|
|
|
export const replaceSpaceWithDash = (str: string): string => str.replace(/ /g, '-');
|
|
|
|
export const splitWithSpace = (content: string): string[] => {
|
|
const trimmedContent = content.trim();
|
|
if (trimmedContent === '') return [];
|
|
return trimmedContent.split(' ');
|
|
};
|
|
|
|
/**
|
|
* Strip alpha channel from a color, returning a fully opaque hex color
|
|
* Supports: #RGB, #RGBA, #RRGGBB, #RRGGBBAA, rgb(), rgba()
|
|
*/
|
|
export const stripAlphaFromColor = (color: string): string => {
|
|
// Handle rgba() format
|
|
const rgbaMatch = color.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
|
|
if (rgbaMatch) {
|
|
const r = parseInt(rgbaMatch[1], 10).toString(16).padStart(2, '0');
|
|
const g = parseInt(rgbaMatch[2], 10).toString(16).padStart(2, '0');
|
|
const b = parseInt(rgbaMatch[3], 10).toString(16).padStart(2, '0');
|
|
return `#${r}${g}${b}`.toUpperCase();
|
|
}
|
|
|
|
// Handle hex format
|
|
let hex = color.replace('#', '');
|
|
|
|
// Convert shorthand #RGB or #RGBA to full form
|
|
if (hex.length === 3 || hex.length === 4) {
|
|
hex = hex
|
|
.split('')
|
|
.map((c) => c + c)
|
|
.join('');
|
|
}
|
|
|
|
// Take only the first 6 characters (RGB), ignore alpha if present
|
|
return `#${hex.substring(0, 6).toUpperCase()}`;
|
|
};
|
|
|
|
/**
|
|
* Calculate contrasting text color (black or white) for a given background color
|
|
* @param bgColor - Hex color string (e.g., '#RRGGBB' or '#RRGGBBAA')
|
|
* @returns '#000000' for light backgrounds, '#FFFFFF' for dark backgrounds
|
|
*/
|
|
export const getContrastingTextColor = (bgColor: string): string => {
|
|
// Remove # if present
|
|
const hex = bgColor.replace('#', '');
|
|
|
|
// Parse RGB values (ignore alpha if present)
|
|
const r = parseInt(hex.substring(0, 2), 16);
|
|
const g = parseInt(hex.substring(2, 4), 16);
|
|
const b = parseInt(hex.substring(4, 6), 16);
|
|
|
|
// Calculate relative luminance using WCAG formula
|
|
const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
|
|
|
|
// Return black for light backgrounds, white for dark backgrounds
|
|
return luminance > 0.5 ? '#000000' : '#FFFFFF';
|
|
};
|
|
|
|
/**
|
|
* Calculate shadow color for text - white shadow only for very dark text
|
|
* @param textColor - Hex color string (e.g., '#RRGGBB')
|
|
* @returns '#FFFFFF' only for very dark text (close to black), '#000000' otherwise
|
|
*/
|
|
export const getTextShadowColor = (textColor: string): string => {
|
|
// Remove # if present
|
|
const hex = textColor.replace('#', '');
|
|
|
|
// Parse RGB values (ignore alpha if present)
|
|
const r = parseInt(hex.substring(0, 2), 16);
|
|
const g = parseInt(hex.substring(2, 4), 16);
|
|
const b = parseInt(hex.substring(4, 6), 16);
|
|
|
|
// Calculate relative luminance using WCAG formula
|
|
const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
|
|
|
|
// Return white shadow only for very dark text (luminance < 0.2)
|
|
return luminance < 0.2 ? '#FFFFFF' : '#000000';
|
|
};
|