@kennofizet/apphub-frontend 0.1.0

package/src/modules/desktop/utils/desktopIconGroups.js

@@ -0,0 +1,103 @@
+/** Grid cell key for grouping apps at the same desktop position. */
+export function cellKey(x, y) {
+  return `${x},${y}`
+}
+
+/** Apps sharing the same snapped desktop cell. */
+export function findAppsAtCell(apps, x, y, excludeIds = []) {
+  const excluded = new Set(excludeIds)
+  return (apps ?? []).filter(
+    (a) =>
+      a.desktopX === x &&
+      a.desktopY === y &&
+      !excluded.has(a.id),
+  )
+}
+
+/** Desktop layout: single icons or groups (2+ apps in one cell). */
+export function buildDesktopItems(apps) {
+  const byCell = new Map()
+
+  for (const app of apps ?? []) {
+    if (app.desktopX == null || app.desktopY == null) continue
+    const key = cellKey(app.desktopX, app.desktopY)
+    if (!byCell.has(key)) byCell.set(key, [])
+    byCell.get(key).push(app)
+  }
+
+  const items = []
+  for (const [key, cellApps] of byCell) {
+    const [x, y] = key.split(',').map(Number)
+    if (cellApps.length >= 2) {
+      items.push({ type: 'group', id: `group-${key}`, apps: cellApps, x, y })
+    } else {
+      items.push({ type: 'single', app: cellApps[0], id: cellApps[0].id, x, y })
+    }
+  }
+  return items
+}
+
+export function occupiedCells(apps) {
+  const cells = new Set()
+  for (const app of apps ?? []) {
+    if (app.desktopX == null || app.desktopY == null) continue
+    cells.add(cellKey(app.desktopX, app.desktopY))
+  }
+  return cells
+}
+
+/** Move one or more apps to a grid cell (creates or joins a group). */
+export function moveAppsToCell(apps, x, y) {
+  for (const app of apps) {
+    app.desktopX = x
+    app.desktopY = y
+  }
+}
+
+/** Preview apps at drop target after a drag merge. */
+export function previewGroupAtCell(allApps, draggedApps, x, y) {
+  const draggedIds = new Set(draggedApps.map((a) => a.id))
+  const existing = findAppsAtCell(allApps, x, y, [...draggedIds])
+  const merged = [...existing]
+  for (const app of draggedApps) {
+    if (!merged.some((a) => a.id === app.id)) merged.push(app)
+  }
+  return merged
+}
+
+/** Find layout item (single or group) at a grid cell. */
+export function findLayoutItemAt(items, x, y) {
+  return (items ?? []).find((item) => item.x === x && item.y === y) ?? null
+}
+
+export function defaultGroupLabel(labels, count) {
+  return count > 1 ? `${labels.group_label} (${count})` : labels.group_label
+}
+
+export function getGroupDisplayName(settings, x, y, labels, count) {
+  const key = cellKey(x, y)
+  const custom = settings?.groupNames?.[key]
+  if (custom) return custom
+  return defaultGroupLabel(labels, count)
+}
+
+export function setGroupDisplayName(settings, x, y, name, labels, count) {
+  if (!settings.groupNames) settings.groupNames = {}
+  const key = cellKey(x, y)
+  const trimmed = String(name ?? '').trim()
+  const fallback = defaultGroupLabel(labels, count)
+  if (!trimmed || trimmed === fallback) {
+    delete settings.groupNames[key]
+    return
+  }
+  settings.groupNames[key] = trimmed
+}
+
+export function migrateGroupDisplayName(settings, fromX, fromY, toX, toY) {
+  const fromKey = cellKey(fromX, fromY)
+  const toKey = cellKey(toX, toY)
+  if (fromKey === toKey || !settings?.groupNames?.[fromKey]) return
+  if (!settings.groupNames) settings.groupNames = {}
+  settings.groupNames[toKey] = settings.groupNames[fromKey]
+  delete settings.groupNames[fromKey]
+}

package/src/modules/desktop/utils/desktopSession.js

@@ -0,0 +1,40 @@
+import { safeParseJson, sanitizeDesktopSession } from '../../../utils/safeStorage.js'
+
+const SESSION_KEY = 'apphub-desktop-session'
+
+export function loadDesktopSession() {
+  try {
+    const raw = localStorage.getItem(SESSION_KEY)
+    const parsed = safeParseJson(raw, 512 * 1024)
+    return parsed ? sanitizeDesktopSession(parsed) : null
+  } catch {
+    return null
+  }
+}
+
+export function saveDesktopSession(session) {
+  try {
+    localStorage.setItem(SESSION_KEY, JSON.stringify(session))
+  } catch {
+    /* ignore */
+  }
+}
+
+export function buildDesktopSession(shell, wm, appStore, settings = null) {
+  return {
+    windows: wm.state.windows.map((win) => ({
+      appId: win.id.replace(/^win-/, ''),
+      minimized: !!win.minimized,
+      display: win.display ?? 'mini',
+      x: win.x,
+      y: win.y,
+      width: win.width,
+      height: win.height,
+      zIndex: win.zIndex,
+    })),
+    activeId: wm.state.activeId,
+    userApps: shell.state.userApps.map((app) => ({ ...app })),
+    installedSlugs: [...(appStore?.state?.installedSlugs ?? [])],
+    settings: settings ? { ...settings } : undefined,
+  }
+}

package/src/modules/desktop/utils/desktopSettings.js

@@ -0,0 +1,37 @@
+import { safeParseJson, sanitizeDesktopSettings } from '../../../utils/safeStorage.js'
+
+const SETTINGS_KEY = 'apphub-desktop-settings'
+
+const defaults = {
+  snapToGrid: true,
+  theme: 'dark',
+  groupNames: {},
+}
+
+export function loadDesktopSettings() {
+  try {
+    const raw = localStorage.getItem(SETTINGS_KEY)
+    const parsed = safeParseJson(raw, 64 * 1024)
+    const sanitized = parsed ? sanitizeDesktopSettings(parsed) : null
+    return { ...defaults, ...sanitized }
+  } catch {
+    return { ...defaults }
+  }
+}
+
+export function applyDesktopSettings(target, source) {
+  const sanitized = sanitizeDesktopSettings(source)
+  if (!sanitized) return
+  if (sanitized.snapToGrid !== undefined) target.snapToGrid = sanitized.snapToGrid
+  if (sanitized.theme !== undefined) target.theme = sanitized.theme
+  if (sanitized.groupNames) target.groupNames = sanitized.groupNames
+  if (sanitized.builtinPositions) target.builtinPositions = sanitized.builtinPositions
+}
+
+export function saveDesktopSettings(settings) {
+  try {
+    localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings))
+  } catch {
+    /* ignore */
+  }
+}

package/src/modules/desktop/utils/dropPackageParser.js

@@ -0,0 +1,140 @@
+import { clampString, isValidSlug } from '../../../utils/safeStorage.js'
+
+const MAX_MANIFEST_BYTES = 64 * 1024
+
+/**
+ * Parse dropped files into an install intent.
+ * Hosted publish: drop .zip (manifest.json inside zip) → draft submit, await DEV approval.
+ */
+export async function parseDropFiles(dataTransfer) {
+  let files = [...(dataTransfer?.files ?? [])]
+
+  if (!files.length && dataTransfer?.items?.length) {
+    for (const item of dataTransfer.items) {
+      if (item.kind === 'file') {
+        const file = item.getAsFile()
+        if (file) files.push(file)
+      }
+    }
+  }
+
+  if (!files.length) return null
+
+  const zipFile = files.find((f) => /\.zip$/i.test(f.name))
+  const jsonFile = files.find((f) =>
+    f.name.endsWith('.apphub.json') || f.name === 'manifest.json' || f.type === 'application/json',
+  )
+
+  if (zipFile) {
+    let manifest = null
+    if (jsonFile) {
+      manifest = await readManifestFile(jsonFile)
+    }
+
+    if (!manifest || isHostedPublishManifest(manifest)) {
+      return buildPublishIntent(zipFile, manifest)
+    }
+  }
+
+  if (jsonFile) {
+    const manifest = await readManifestFile(jsonFile)
+    if (!manifest) return null
+
+    if (manifest.source === 'appstore' && manifest.slug) {
+      const slug = normalizeSlug(manifest.slug)
+      if (!slug) return null
+      return {
+        method: 'appstore',
+        slug,
+        name: clampString(manifest.name) || slug,
+        icon: clampString(manifest.icon, 16) || '🛒',
+        description: clampString(manifest.description, 500),
+      }
+    }
+
+    if (manifest.source === 'local' || (manifest.name && !isHostedPublishManifest(manifest))) {
+      const slug = normalizeSlug(manifest.slug ?? manifest.name ?? stripExt(jsonFile.name))
+      if (!slug) return null
+      return {
+        method: 'local',
+        slug,
+        name: clampString(manifest.name) || stripExt(jsonFile.name),
+        icon: clampString(manifest.icon, 16) || pickIcon(files),
+        description: clampString(manifest.description, 500),
+      }
+    }
+  }
+
+  const primary = files[0]
+  if (primary.size > 50 * 1024 * 1024) return null
+
+  return {
+    method: 'local',
+    slug: slugify(stripExt(primary.name)),
+    name: stripExt(primary.name),
+    icon: pickIcon(files),
+    description: '',
+    fileName: primary.name,
+  }
+}
+
+function isHostedPublishManifest(manifest) {
+  if (!manifest || typeof manifest !== 'object') return false
+  const runtime = typeof manifest.runtime_type === 'string' ? manifest.runtime_type.toLowerCase() : ''
+  if (runtime === 'hosted') return true
+  if (manifest.source === 'publish' || manifest.source === 'hosted') return true
+  return Boolean(manifest.slug && manifest.name && !manifest.entry_url)
+}
+
+function buildPublishIntent(zipFile, manifest) {
+  const slug = manifest?.slug ? normalizeSlug(manifest.slug) : null
+  const name = manifest?.name
+    ? clampString(manifest.name)
+    : stripExt(zipFile.name)
+
+  return {
+    method: 'publish',
+    zipFile,
+    manifest,
+    slug,
+    name: name || stripExt(zipFile.name),
+    icon: clampString(manifest?.icon, 16) || '📦',
+    description: clampString(manifest?.description ?? manifest?.short_description, 500),
+  }
+}
+
+async function readManifestFile(jsonFile) {
+  if (!jsonFile || jsonFile.size > MAX_MANIFEST_BYTES) return null
+  try {
+    const text = await jsonFile.text()
+    if (text.length > MAX_MANIFEST_BYTES) return null
+    const manifest = JSON.parse(text)
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) return null
+    return manifest
+  } catch {
+    return null
+  }
+}
+
+function stripExt(name) {
+  return name.replace(/\.[^.]+$/, '')
+}
+
+function normalizeSlug(value) {
+  const slug = slugify(value)
+  return isValidSlug(slug) ? slug : null
+}
+
+function slugify(value) {
+  return String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '') || 'dropped-app'
+}
+
+function pickIcon(files) {
+  const img = files.find((f) => f.type.startsWith('image/'))
+  if (img) return '🖼️'
+  if (files.some((f) => /\.zip$/i.test(f.name))) return '📦'
+  return '📄'
+}

package/src/modules/desktop/utils/duplicateAppUtils.js

@@ -0,0 +1,28 @@
+export function normalizeAppName(name) {
+  return String(name ?? '').trim()
+}
+
+export function findAppByName(name, apps) {
+  const target = normalizeAppName(name).toLowerCase()
+  if (!target) return null
+  return (apps ?? []).find((a) => normalizeAppName(a.name).toLowerCase() === target) ?? null
+}
+
+/** Next name: "App" → "App 2", existing "App 2" → "App 3" */
+export function nextDuplicateName(baseName, apps) {
+  const base = normalizeAppName(baseName)
+  const names = new Set((apps ?? []).map((a) => normalizeAppName(a.name)))
+  if (!names.has(base)) return base
+  let n = 2
+  while (names.has(`${base} ${n}`)) n += 1
+  return `${base} ${n}`
+}
+
+export function nextDuplicateSlug(baseSlug, apps) {
+  const base = String(baseSlug ?? '').trim() || 'app'
+  const slugs = new Set((apps ?? []).map((a) => a.slug))
+  if (!slugs.has(base)) return base
+  let n = 2
+  while (slugs.has(`${base}-${n}`)) n += 1
+  return `${base}-${n}`
+}

package/src/modules/desktop/utils/hubKeyboardSettings.js

@@ -0,0 +1,63 @@
+import { safeParseJson } from '../../../utils/safeStorage.js'
+
+const STORAGE_KEY = 'apphub-keyboard-settings'
+
+/** Browser-safe modifier — Windows (⊞)+arrow is captured by the OS, not the page. */
+export const KEYBOARD_MODIFIER = 'ctrl-alt'
+
+const defaults = {
+  enabled: true,
+  modifier: KEYBOARD_MODIFIER,
+}
+
+export function loadHubKeyboardSettings() {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY)
+    const parsed = safeParseJson(raw, 8 * 1024)
+    const merged = { ...defaults, ...sanitizeHubKeyboardSettings(parsed) }
+    return normalizeHubKeyboardSettings(merged)
+  } catch {
+    return { ...defaults }
+  }
+}
+
+export function sanitizeHubKeyboardSettings(parsed) {
+  if (!parsed || typeof parsed !== 'object') return {}
+  return {
+    enabled: typeof parsed.enabled === 'boolean' ? parsed.enabled : undefined,
+    modifier: parsed.modifier === KEYBOARD_MODIFIER ? KEYBOARD_MODIFIER : undefined,
+  }
+}
+
+/** Coerce legacy Win-key preference saved before browser limitation was enforced. */
+export function normalizeHubKeyboardSettings(settings) {
+  return {
+    enabled: settings.enabled !== false,
+    modifier: KEYBOARD_MODIFIER,
+  }
+}
+
+export function saveHubKeyboardSettings(settings) {
+  try {
+    const normalized = normalizeHubKeyboardSettings(settings)
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(normalized))
+  } catch {
+    /* ignore */
+  }
+}
+
+/** @returns {'left'|'right'|'up'|'down'|null} */
+export function matchSnapShortcut(event, settings) {
+  if (!settings?.enabled) return null
+  if (!event.ctrlKey || !event.altKey) return null
+  if (event.metaKey) return null
+
+  const map = {
+    ArrowLeft: 'left',
+    ArrowRight: 'right',
+    ArrowUp: 'up',
+    ArrowDown: 'down',
+  }
+
+  return map[event.key] ?? null
+}

package/src/modules/desktop/utils/recentApps.js

@@ -0,0 +1,148 @@
+const STORAGE_KEY = 'apphub-recent-apps'
+export const MAX_RECENT = 10
+export const MAX_SUGGESTED = 6
+const MAX_OPEN_LOG = 48
+const MAX_OPEN_COUNT = 999_999
+
+function clampOpenCount(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) return 1
+  return Math.min(Math.floor(value), MAX_OPEN_COUNT)
+}
+
+function clampOpenedAt(value, fallback = Date.now()) {
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) return value
+  return fallback
+}
+
+function sanitizeEntry(entry, fallbackOpenedAt = Date.now()) {
+  if (typeof entry === 'string' && entry.length > 0) {
+    return { id: entry.slice(0, 80), openCount: 1, openedAt: fallbackOpenedAt }
+  }
+  if (entry && typeof entry === 'object' && typeof entry.id === 'string' && entry.id.length > 0) {
+    const openCount =
+      typeof entry.openCount === 'number' ? clampOpenCount(entry.openCount) : 1
+    const openedAt = clampOpenedAt(entry.openedAt, fallbackOpenedAt)
+    return { id: entry.id.slice(0, 80), openCount, openedAt }
+  }
+  return null
+}
+
+function mergeEntries(a, b) {
+  return {
+    id: a.id,
+    openCount: clampOpenCount(Math.max(a.openCount, b.openCount)),
+    openedAt: Math.max(a.openedAt, b.openedAt),
+  }
+}
+
+/** One entry per app with merged openCount and latest openedAt. */
+export function normalizeOpenLog(log) {
+  if (!Array.isArray(log) || !log.length) return []
+  const byId = new Map()
+  for (const entry of log) {
+    const sanitized = sanitizeEntry(entry)
+    if (!sanitized) continue
+    const prev = byId.get(sanitized.id)
+    byId.set(sanitized.id, prev ? mergeEntries(prev, sanitized) : sanitized)
+  }
+  return [...byId.values()]
+}
+
+/** Most recently opened first. */
+export function sortOpenLogByTime(log) {
+  return [...normalizeOpenLog(log)].sort((a, b) => b.openedAt - a.openedAt)
+}
+
+/** Most opened first; ties broken by most recent open. */
+export function sortOpenLogByCount(log) {
+  return [...normalizeOpenLog(log)].sort(
+    (a, b) => b.openCount - a.openCount || b.openedAt - a.openedAt,
+  )
+}
+
+export function loadRecentOpenLog() {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY)
+    if (!raw || typeof raw !== 'string' || raw.length > 16 * 1024) return []
+    const parsed = JSON.parse(raw)
+    if (!Array.isArray(parsed)) return []
+
+    const now = Date.now()
+    if (parsed.length && typeof parsed[0] === 'string') {
+      return normalizeOpenLog(
+        parsed.map((id, index) => sanitizeEntry(id, now - index * 1000)),
+      ).slice(0, MAX_OPEN_LOG)
+    }
+
+    return normalizeOpenLog(parsed.map((entry) => sanitizeEntry(entry))).slice(0, MAX_OPEN_LOG)
+  } catch {
+    return []
+  }
+}
+
+export function saveRecentOpenLog(log) {
+  try {
+    const normalized = normalizeOpenLog(log).slice(0, MAX_OPEN_LOG)
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(normalized))
+    return normalized
+  } catch {
+    return Array.isArray(log) ? log : []
+  }
+}
+
+export function recordRecentApp(appId, currentLog = null) {
+  if (!appId || typeof appId !== 'string') {
+    return normalizeOpenLog(Array.isArray(currentLog) ? currentLog : loadRecentOpenLog())
+  }
+  const base = normalizeOpenLog(Array.isArray(currentLog) ? currentLog : loadRecentOpenLog())
+  const existing = base.find((entry) => entry.id === appId)
+  const now = Date.now()
+  const bumped = {
+    id: appId,
+    openCount: (existing?.openCount ?? 0) + 1,
+    openedAt: now,
+  }
+  const merged = [bumped, ...base.filter((entry) => entry.id !== appId)]
+  return saveRecentOpenLog(merged)
+}
+
+export function getRecentAppIds(log = loadRecentOpenLog()) {
+  return sortOpenLogByTime(log)
+    .map((entry) => entry.id)
+    .slice(0, MAX_RECENT)
+}
+
+/** @deprecated use loadRecentOpenLog */
+export function loadRecentAppIds() {
+  return getRecentAppIds()
+}
+
+export function resolveRecentApps(catalog, log = loadRecentOpenLog()) {
+  if (!Array.isArray(catalog) || !catalog.length) return []
+  const byId = new Map(catalog.map((app) => [app.id, app]))
+  return sortOpenLogByTime(log)
+    .map((entry) => byId.get(entry.id))
+    .filter(Boolean)
+    .slice(0, MAX_RECENT)
+}
+
+export function resolveSuggestedApps(catalog, log = loadRecentOpenLog(), options = {}) {
+  const limit = options.limit ?? MAX_SUGGESTED
+  const excludeIds = options.excludeIds ?? new Set()
+  const includeBuiltins = options.includeBuiltins === true
+  if (!Array.isArray(catalog) || !catalog.length || !Array.isArray(log) || !log.length) return []
+
+  const byId = new Map(catalog.map((app) => [app.id, app]))
+  const result = []
+
+  for (const entry of sortOpenLogByCount(log)) {
+    if (result.length >= limit) break
+    if (excludeIds.has(entry.id)) continue
+    const app = byId.get(entry.id)
+    if (!app) continue
+    if (!includeBuiltins && app.builtin) continue
+    result.push(app)
+  }
+
+  return result
+}

package/src/modules/desktop/utils/startMenuFavorites.js

@@ -0,0 +1,100 @@
+import { safeParseJson } from '../../../utils/safeStorage.js'
+import { sortOpenLogByTime } from './recentApps.js'
+
+const STORAGE_KEY = 'apphub-start-menu-favorites'
+const MAX_FAVORITES = 32
+
+export const START_MENU_LIST_MAX = 10
+export const START_MENU_FAVORITES_MAX = 5
+
+function sanitizeFavorites(parsed) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  const raw = parsed.favorites ?? parsed
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+
+  const favorites = {}
+  let count = 0
+  for (const [key, value] of Object.entries(raw)) {
+    if (count >= MAX_FAVORITES) break
+    const id = typeof key === 'string' ? key.slice(0, 80) : ''
+    if (!id) continue
+    favorites[id] = {
+      visible: value && typeof value === 'object' && value.visible === false ? false : true,
+    }
+    count += 1
+  }
+  return favorites
+}
+
+export function loadStartMenuFavorites() {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY)
+    const parsed = safeParseJson(raw, 16 * 1024)
+    const favorites = sanitizeFavorites(parsed)
+    if (favorites) return favorites
+  } catch {
+    /* ignore */
+  }
+  return {}
+}
+
+export function saveStartMenuFavorites(favorites) {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({ favorites }))
+  } catch {
+    /* ignore */
+  }
+}
+
+export function isAppFavorite(favorites, appId) {
+  return !!(appId && favorites && Object.prototype.hasOwnProperty.call(favorites, appId))
+}
+
+export function isAppVisibleAsFavorite(favorites, appId) {
+  if (!isAppFavorite(favorites, appId)) return false
+  return favorites[appId].visible !== false
+}
+
+export function favoriteApp(favorites, appId) {
+  if (!appId) return
+  favorites[appId] = { visible: true }
+}
+
+export function unfavoriteApp(favorites, appId) {
+  if (!appId || !favorites) return
+  delete favorites[appId]
+}
+
+export function setFavoriteVisible(favorites, appId, visible) {
+  if (!isAppFavorite(favorites, appId)) return
+  favorites[appId].visible = !!visible
+}
+
+export function listFavoriteAppIds(favorites) {
+  return Object.keys(favorites ?? {})
+}
+
+export function resolveVisibleFavoriteApps(catalog, favorites) {
+  if (!Array.isArray(catalog) || !catalog.length) return []
+  const byId = new Map(catalog.map((app) => [app.id, app]))
+  return listFavoriteAppIds(favorites)
+    .filter((id) => isAppVisibleAsFavorite(favorites, id))
+    .map((id) => byId.get(id))
+    .filter(Boolean)
+}
+
+export function resolveStartMenuFavoriteApps(catalog, favorites) {
+  return resolveVisibleFavoriteApps(catalog, favorites).slice(0, START_MENU_FAVORITES_MAX)
+}
+
+export function resolveStartMenuRecentApps(catalog, favorites, openLog) {
+  const favoriteApps = resolveStartMenuFavoriteApps(catalog, favorites)
+  const favoriteIdSet = new Set(favoriteApps.map((app) => app.id))
+  const recentSlots = Math.max(0, START_MENU_LIST_MAX - favoriteApps.length)
+  const byId = new Map((catalog ?? []).map((app) => [app.id, app]))
+  return sortOpenLogByTime(openLog ?? [])
+    .filter((entry) => !favoriteIdSet.has(entry.id))
+    .slice(0, recentSlots)
+    .map((entry) => byId.get(entry.id))
+    .filter(Boolean)
+}