155 lines
4.0 KiB
TypeScript
155 lines
4.0 KiB
TypeScript
import { type ClassValue, clsx } from "clsx"
|
|
// import { toast } from "sonner"
|
|
import { twMerge } from "tailwind-merge"
|
|
import fileExtToLang from "./file-extension-to-language.json"
|
|
import { KnownPlatform, TFile, TFolder, UserLink } from "./types"
|
|
|
|
export function cn(...inputs: ClassValue[]) {
|
|
return twMerge(clsx(inputs))
|
|
}
|
|
|
|
export function processFileType(file: string) {
|
|
const extension = file.split(".").pop()
|
|
const fileExtToLangMap = fileExtToLang as Record<string, string>
|
|
if (extension && fileExtToLangMap[extension]) {
|
|
return fileExtToLangMap[extension]
|
|
}
|
|
|
|
return "plaintext"
|
|
}
|
|
|
|
export function validateName(
|
|
newName: string,
|
|
oldName: string,
|
|
type: "file" | "folder"
|
|
) {
|
|
if (newName === oldName || newName.length === 0) {
|
|
return { status: false, message: "" }
|
|
}
|
|
if (
|
|
newName.includes("/") ||
|
|
newName.includes("\\") ||
|
|
newName.includes(" ") ||
|
|
(type === "file" && !newName.includes(".")) ||
|
|
(type === "folder" && newName.includes("."))
|
|
) {
|
|
return { status: false, message: "Invalid file name." }
|
|
}
|
|
return { status: true, message: "" }
|
|
}
|
|
|
|
export function debounce<T extends (...args: any[]) => void>(
|
|
func: T,
|
|
wait: number
|
|
): T {
|
|
let timeout: NodeJS.Timeout | null = null
|
|
return function (...args: Parameters<T>) {
|
|
if (timeout) {
|
|
clearTimeout(timeout)
|
|
}
|
|
timeout = setTimeout(() => func(...args), wait)
|
|
} as T
|
|
}
|
|
|
|
// Deep merge utility function
|
|
export const deepMerge = (target: any, source: any) => {
|
|
const output = { ...target }
|
|
if (isObject(target) && isObject(source)) {
|
|
Object.keys(source).forEach((key) => {
|
|
if (isObject(source[key])) {
|
|
if (!(key in target)) {
|
|
Object.assign(output, { [key]: source[key] })
|
|
} else {
|
|
output[key] = deepMerge(target[key], source[key])
|
|
}
|
|
} else {
|
|
Object.assign(output, { [key]: source[key] })
|
|
}
|
|
})
|
|
}
|
|
return output
|
|
}
|
|
|
|
const isObject = (item: any) => {
|
|
return item && typeof item === "object" && !Array.isArray(item)
|
|
}
|
|
|
|
export function sortFileExplorer(
|
|
items: (TFile | TFolder)[]
|
|
): (TFile | TFolder)[] {
|
|
return items
|
|
.sort((a, b) => {
|
|
// First, sort by type (folders before files)
|
|
if (a.type !== b.type) {
|
|
return a.type === "folder" ? -1 : 1
|
|
}
|
|
|
|
// Then, sort alphabetically by name
|
|
return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
|
|
})
|
|
.map((item) => {
|
|
// If it's a folder, recursively sort its children
|
|
if (item.type === "folder") {
|
|
return {
|
|
...item,
|
|
children: sortFileExplorer(item.children),
|
|
}
|
|
}
|
|
return item
|
|
})
|
|
}
|
|
|
|
export function parseSocialLink(url: string): UserLink {
|
|
try {
|
|
// Handle empty or invalid URLs
|
|
if (!url) return { url: "", platform: "generic" }
|
|
|
|
// Remove protocol and www prefix for consistent parsing
|
|
const cleanUrl = url
|
|
.toLowerCase()
|
|
.replace(/^https?:\/\//, "")
|
|
.replace(/^www\./, "")
|
|
.split("/")[0] // Get just the domain part
|
|
|
|
// Platform detection mapping
|
|
const platformPatterns: Record<
|
|
Exclude<KnownPlatform, "generic">,
|
|
RegExp
|
|
> = {
|
|
github: /github\.com/,
|
|
twitter: /(?:twitter\.com|x\.com|t\.co)/,
|
|
instagram: /instagram\.com/,
|
|
bluesky: /(?:bsky\.app|bluesky\.social)/,
|
|
linkedin: /linkedin\.com/,
|
|
youtube: /(?:youtube\.com|youtu\.be)/,
|
|
twitch: /twitch\.tv/,
|
|
discord: /discord\.(?:gg|com)/,
|
|
mastodon: /mastodon\.(?:social|online|world)/,
|
|
threads: /threads\.net/,
|
|
gitlab: /gitlab\.com/,
|
|
}
|
|
|
|
// Check URL against each pattern
|
|
for (const [platform, pattern] of Object.entries(platformPatterns)) {
|
|
if (pattern.test(cleanUrl)) {
|
|
return {
|
|
url,
|
|
platform: platform as KnownPlatform,
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fall back to generic if no match found
|
|
return {
|
|
url,
|
|
platform: "generic",
|
|
}
|
|
} catch (error) {
|
|
console.error("Error parsing social link:", error)
|
|
return {
|
|
url: url || "",
|
|
platform: "generic",
|
|
}
|
|
}
|
|
}
|