@rokkit/ui 1.0.0-next.99 → 1.0.1

package/src/utils/shiki.ts

@@ -0,0 +1,114 @@
+/**
+ * Shiki syntax highlighting utility
+ */
+
+import { createHighlighter, type Highlighter, type BundledLanguage, type BundledTheme } from 'shiki'
+
+let highlighter: Highlighter | null = null
+let isInitializing = false
+let initPromise: Promise<Highlighter> | null = null
+
+// Supported languages for the application
+const SUPPORTED_LANGUAGES: BundledLanguage[] = [
+	'svelte',
+	'javascript',
+	'typescript',
+	'css',
+	'html',
+	'json',
+	'bash',
+	'shell',
+	'markdown',
+	'yaml',
+	'sql'
+]
+
+// Available themes
+const THEMES: BundledTheme[] = ['github-light', 'github-dark']
+
+/**
+ * Initialize Shiki highlighter (singleton)
+ */
+function initializeHighlighter(): Promise<Highlighter> {
+	if (highlighter) return Promise.resolve(highlighter)
+
+	if (isInitializing && initPromise) {
+		return initPromise
+	}
+
+	isInitializing = true
+
+	initPromise = createHighlighter({
+		themes: THEMES,
+		langs: SUPPORTED_LANGUAGES
+	})
+		.then((hl: Highlighter) => {
+			highlighter = hl
+			isInitializing = false
+			return hl
+		})
+		.catch((error: Error) => {
+			isInitializing = false
+			initPromise = null
+			throw error
+		})
+
+	return initPromise
+}
+
+export interface HighlightOptions {
+	/** Language for syntax highlighting */
+	lang?: BundledLanguage | string
+	/** Theme to use (defaults based on user preference) */
+	theme?: BundledTheme | 'light' | 'dark'
+}
+
+/**
+ * Highlight code using Shiki
+ *
+ * @param code - The code to highlight
+ * @param options - Highlighting options
+ * @returns The highlighted code as HTML
+ */
+function resolveTheme(themeOption: string | undefined): BundledTheme {
+	if (themeOption === 'light') return 'github-light'
+	if (themeOption === 'dark' || !themeOption) return 'github-dark'
+	return themeOption as BundledTheme
+}
+
+function isValidCode(code: unknown): code is string {
+	return Boolean(code) && typeof code === 'string'
+}
+
+export async function highlightCode(code: string, options: HighlightOptions = {}): Promise<string> {
+	if (!isValidCode(code)) throw new Error('Invalid code provided for highlighting')
+
+	const hl = await initializeHighlighter()
+	const lang = (options.lang ?? 'text') as BundledLanguage
+	const theme = resolveTheme(options.theme)
+	const loadedLangs = hl.getLoadedLanguages()
+	const effectiveLang = loadedLangs.includes(lang) ? lang : 'text'
+
+	return hl
+		.codeToHtml(code, { lang: effectiveLang, theme })
+		.replace(/(<pre[^>]+) style="[^"]*"/, '$1')
+}
+
+/**
+ * Preload the syntax highlighter for faster initial rendering
+ * Errors are silently ignored since preloading is optional
+ */
+export async function preloadHighlighter(): Promise<void> {
+	try {
+		await initializeHighlighter()
+	} catch {
+		// Preload failures are non-critical - highlighting will still work on demand
+	}
+}
+
+/**
+ * Get list of supported languages
+ */
+export function getSupportedLanguages(): readonly string[] {
+	return SUPPORTED_LANGUAGES
+}

package/src/utils/upload.js

@@ -0,0 +1,145 @@
+/**
+ * Upload utility functions — shared helpers for UploadTarget and UploadProgress.
+ * Pure functions with no Svelte dependency.
+ */
+
+const ARCHIVE_TYPES = new Set(['application/zip', 'application/gzip', 'application/x-tar'])
+
+/**
+ * Check if a file matches an accept string (comma-separated MIME types and extensions).
+ * @param {{ type: string, name: string }} file
+ * @param {string | null | undefined} accept - e.g. 'image/*,.pdf,application/json'
+ * @returns {boolean}
+ */
+export function matchesAccept(file, accept) {
+	if (!accept) return true
+
+	const tokens = accept
+		.split(',')
+		.map((t) => t.trim())
+		.filter(Boolean)
+	if (tokens.length === 0) return true
+
+	return tokens.some((token) => {
+		if (token.startsWith('.')) {
+			// Extension match (case-insensitive)
+			return file.name.toLowerCase().endsWith(token.toLowerCase())
+		}
+		if (token.endsWith('/*')) {
+			// Wildcard MIME type match (e.g. image/*)
+			const prefix = token.slice(0, -1) // 'image/'
+			return file.type.startsWith(prefix)
+		}
+		// Exact MIME type match
+		return file.type === token
+	})
+}
+
+/**
+ * Validate a file against accept and maxSize constraints.
+ * @param {{ type: string, name: string, size: number }} file
+ * @param {{ accept?: string, maxSize?: number }} constraints
+ * @returns {true | { reason: 'type' | 'size' }}
+ */
+function hasTypeError(file, accept) {
+	return accept && !matchesAccept(file, accept)
+}
+
+function hasSizeError(file, maxSize) {
+	return maxSize !== undefined && file.size > maxSize
+}
+
+export function validateFile(file, { accept, maxSize } = {}) {
+	if (hasTypeError(file, accept)) return { reason: 'type' }
+	if (hasSizeError(file, maxSize)) return { reason: 'size' }
+	return true
+}
+
+/**
+ * Map a MIME type to an icon class string.
+ * @param {string | null | undefined} mimeType
+ * @returns {string}
+ */
+const MIME_PREFIX_ICONS = [
+	['image/', 'i-lucide:image'],
+	['video/', 'i-lucide:video'],
+	['audio/', 'i-lucide:music'],
+	['text/', 'i-lucide:file-text'],
+	['application/pdf', 'i-lucide:file-text']
+]
+
+function getPrefixIcon(mimeType) {
+	for (const [prefix, icon] of MIME_PREFIX_ICONS) {
+		if (mimeType.startsWith(prefix)) return icon
+	}
+	return null
+}
+
+export function inferIcon(mimeType) {
+	if (!mimeType) return 'i-lucide:file'
+	const prefixIcon = getPrefixIcon(mimeType)
+	if (prefixIcon) return prefixIcon
+	if (ARCHIVE_TYPES.has(mimeType)) return 'i-lucide:archive'
+	return 'i-lucide:file'
+}
+
+/**
+ * Format a byte count as a human-readable size string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`
+	if (bytes < 1024 ** 2) return `${(bytes / 1024).toFixed(1)} KB`
+	if (bytes < 1024 ** 3) return `${(bytes / 1024 ** 2).toFixed(1)} MB`
+	return `${(bytes / 1024 ** 3).toFixed(1)} GB`
+}
+
+/**
+ * Group a flat file array by path field into a nested tree structure.
+ * Root-level items (empty path) stay ungrouped.
+ * Group nodes use `text` as the label field (ProxyItem compatibility).
+ *
+ * @param {Array<Record<string, any>>} items
+ * @param {string} pathField - field name containing the path (e.g. 'path')
+ * @param {string} childrenField - field name for children arrays (e.g. 'children')
+ * @returns {Array<Record<string, any>>}
+ */
+function resolveFolder(ctx, parent, segment, fullPath) {
+	let folder = ctx.folderMap.get(fullPath)
+	if (!folder) {
+		folder = { text: segment, [ctx.childrenField]: [] }
+		ctx.folderMap.set(fullPath, folder)
+		parent.push(folder)
+	}
+	return folder[ctx.childrenField]
+}
+
+function walkSegments(ctx, item, rawPath, root) {
+	const segments = rawPath.split('/').filter(Boolean)
+	let parent = root
+	let fullPath = ''
+	for (const segment of segments) {
+		fullPath = fullPath ? `${fullPath}/${segment}` : segment
+		parent = resolveFolder(ctx, parent, segment, fullPath)
+	}
+	parent.push(item)
+}
+
+export function groupByPath(items, pathField, childrenField) {
+	if (!items?.length) return []
+
+	const root = []
+	const ctx = { folderMap: new Map(), childrenField }
+
+	for (const item of items) {
+		const rawPath = item[pathField]
+		if (!rawPath) {
+			root.push(item)
+			continue
+		}
+		walkSegments(ctx, item, rawPath, root)
+	}
+
+	return root
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Jerry Thomas
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/index.js

@@ -1,8 +0,0 @@
-// skipcq: JS-E1004 - Needed for exposing all components
-export * from '@rokkit/atoms'
-// skipcq: JS-E1004 - Needed for exposing all components
-export * from '@rokkit/molecules'
-// skipcq: JS-E1004 - Needed for exposing all components
-export * from '@rokkit/organisms'
-// skipcq: JS-E1004 - Needed for exposing all components
-export * from '@rokkit/layout'

package/src/wrappers.js

@@ -1,2 +0,0 @@
-// skipcq: JS-E1004 - Needed for exposing all components
-export * from '@rokkit/organisms/wrappers'