create-freakpunch 0.0.0-stage → 0.2.0

package/template/src/components/ui/tooltip.tsx

@@ -0,0 +1,91 @@
+import * as React from "react"
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip"
+import { cn } from "@/lib/utils"
+
+function TooltipProvider({
+  delay = 0,
+  ...props
+}: TooltipPrimitive.Provider.Props) {
+  return (
+    <TooltipPrimitive.Provider
+      data-slot="tooltip-provider"
+      delay={delay}
+      {...props}
+    />
+  )
+}
+
+function Tooltip({ ...props }: TooltipPrimitive.Root.Props) {
+  return <TooltipPrimitive.Root data-slot="tooltip" {...props} />
+}
+
+function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
+}
+
+function tooltipLabels(children: React.ReactNode) {
+  const nodes: React.ReactNode[] = []
+  let text = ""
+  React.Children.toArray(children).forEach((child, index, all) => {
+    if (typeof child !== "string" && typeof child !== "number") {
+      nodes.push(child)
+      return
+    }
+    text += child
+    const next = all[index + 1]
+    if (typeof next === "string" || typeof next === "number") return
+    if (text.trim()) {
+      nodes.push(
+        <span
+          key={`label-${index}`}
+          data-slot="tooltip-label"
+          className="max-w-62"
+        >
+          {text}
+        </span>
+      )
+    }
+    text = ""
+  })
+  return nodes
+}
+
+function TooltipContent({
+  className,
+  side = "top",
+  sideOffset = 8,
+  align = "center",
+  alignOffset = 0,
+  children,
+  ...props
+}: TooltipPrimitive.Popup.Props &
+  Pick<
+    TooltipPrimitive.Positioner.Props,
+    "align" | "alignOffset" | "side" | "sideOffset"
+  >) {
+  return (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Positioner
+        align={align}
+        alignOffset={alignOffset}
+        side={side}
+        sideOffset={sideOffset}
+        className="isolate z-50"
+      >
+        <TooltipPrimitive.Popup
+          data-slot="tooltip-content"
+          className={cn(
+            "z-50 flex w-fit max-w-80 origin-(--transform-origin) items-center gap-2 rounded-md bg-foreground px-2 py-1 text-2xs text-background has-data-[slot=kbd]:pr-1 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+            className
+          )}
+          {...props}
+        >
+          {tooltipLabels(children)}
+          <TooltipPrimitive.Arrow className="z-50 size-2 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-0.5 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:translate-x-[1.5px] data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:translate-x-[-1.5px] data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:translate-x-[-1.5px] data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:translate-x-[1.5px] data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" />
+        </TooltipPrimitive.Popup>
+      </TooltipPrimitive.Positioner>
+    </TooltipPrimitive.Portal>
+  )
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

package/template/src/core/api/demo.ts

@@ -0,0 +1,8 @@
+import { isDemo } from '@/core/config/runtime'
+
+// A glob, not an import: src/demo doesn't exist in installed copies, and this still builds without it.
+const files = import.meta.glob<{ default: Record<string, unknown> }>('/src/demo/index.ts', { eager: true })
+const data = isDemo ? Object.values(files)[0]?.default : undefined
+
+/** Sample content by name, or undefined in real installs. */
+export const demoSeed = <T>(name: string) => data?.[name] as T | undefined

package/template/src/core/api/http.ts

@@ -0,0 +1,76 @@
+import { appConfig } from '@/app.config'
+import { authStore } from '@/core/auth/auth-store'
+import { authMode } from '@/core/config/runtime'
+
+/**
+ * Thin fetch wrapper for the real REST API. Mock services don't use it yet;
+ * real service implementations call `http.get('/products', { query })` etc.
+ */
+export class ApiError extends Error {
+  readonly status: number
+  readonly body: unknown
+
+  constructor(status: number, message: string, body?: unknown) {
+    super(message)
+    this.name = 'ApiError'
+    this.status = status
+    this.body = body
+  }
+}
+
+type Query = Record<string, string | number | boolean | undefined>
+type RequestOptions = Omit<RequestInit, 'body' | 'method'> & { query?: Query; body?: unknown }
+
+function buildUrl(path: string, query?: Query) {
+  const url = new URL(appConfig.apiBaseUrl.replace(/\/$/, '') + path, window.location.origin)
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== undefined && value !== '') url.searchParams.set(key, String(value))
+  }
+  return url.toString()
+}
+
+/** Laravel Sanctum and similar: the server sets this cookie, we echo it in a header. */
+function xsrfHeader(): Record<string, string> {
+  if (authMode !== 'cookie') return {}
+  const match = document.cookie.match(/(?:^|; )XSRF-TOKEN=([^;]+)/)
+  return match ? { 'X-XSRF-TOKEN': decodeURIComponent(match[1]) } : {}
+}
+
+async function request<T>(method: string, path: string, options: RequestOptions = {}): Promise<T> {
+  const { query, body, headers, ...init } = options
+  const token = authStore.getSession()?.token
+
+  // FormData (file uploads) sets its own multipart Content-Type.
+  const isForm = body instanceof FormData
+
+  const res = await fetch(buildUrl(path, query), {
+    ...init,
+    method,
+    ...(authMode === 'cookie' && { credentials: 'include' as const }),
+    headers: {
+      Accept: 'application/json',
+      ...(body !== undefined && !isForm && { 'Content-Type': 'application/json' }),
+      ...(token && { Authorization: `Bearer ${token}` }),
+      ...xsrfHeader(),
+      ...headers,
+    },
+    body: body === undefined ? undefined : isForm ? body : JSON.stringify(body),
+  })
+
+  if (res.status === 401) authStore.clear()
+
+  const data: unknown = res.status === 204 ? undefined : await res.json().catch(() => undefined)
+  if (!res.ok) {
+    const message = (data as { message?: string } | undefined)?.message ?? res.statusText
+    throw new ApiError(res.status, message, data)
+  }
+  return data as T
+}
+
+export const http = {
+  get: <T>(path: string, options?: RequestOptions) => request<T>('GET', path, options),
+  post: <T>(path: string, body?: unknown, options?: RequestOptions) => request<T>('POST', path, { ...options, body }),
+  put: <T>(path: string, body?: unknown, options?: RequestOptions) => request<T>('PUT', path, { ...options, body }),
+  patch: <T>(path: string, body?: unknown, options?: RequestOptions) => request<T>('PATCH', path, { ...options, body }),
+  delete: <T>(path: string, options?: RequestOptions) => request<T>('DELETE', path, options),
+}

package/template/src/core/api/mock.ts

@@ -0,0 +1,88 @@
+import { storage } from '@/core/lib/storage'
+import { ApiError } from './http'
+import type { ListParams, Paginated } from './types'
+
+/** Simulated network latency for mock services. */
+export function delay(min = 250, max = 650) {
+  return new Promise<void>((resolve) => setTimeout(resolve, min + Math.random() * (max - min)))
+}
+
+export function notFound(entity: string, id: string): never {
+  throw new ApiError(404, `${entity} ${id} not found`)
+}
+
+/** Deterministic PRNG so mock data is the same on every load. */
+export function seededRandom(seed: number) {
+  let s = seed
+  return () => {
+    s = (s * 16807) % 2147483647
+    return (s - 1) / 2147483646
+  }
+}
+
+/**
+ * Applies search, sort and pagination to an in-memory list the same way a
+ * backend would. Filters are applied by the caller before this.
+ */
+export function paginate<T>(
+  rows: T[],
+  params: ListParams<unknown>,
+  searchFields: (keyof T)[],
+): Paginated<T> {
+  let result = rows
+  const q = params.search?.trim().toLowerCase()
+  if (q) {
+    result = result.filter((row) => searchFields.some((f) => String(row[f]).toLowerCase().includes(q)))
+  }
+  if (params.sort) {
+    const { field, direction } = params.sort
+    const dir = direction === 'asc' ? 1 : -1
+    result = [...result].sort((a, b) => {
+      const av = a[field as keyof T]
+      const bv = b[field as keyof T]
+      if (typeof av === 'number' && typeof bv === 'number') return (av - bv) * dir
+      return String(av).localeCompare(String(bv)) * dir
+    })
+  }
+  const start = (params.page - 1) * params.pageSize
+  return {
+    items: result.slice(start, start + params.pageSize),
+    total: result.length,
+    page: params.page,
+    pageSize: params.pageSize,
+  }
+}
+
+/** A single mock record (e.g. company settings) persisted to localStorage (`fp:mock:<name>`). */
+export function createMockDocument<T>(name: string, seed: () => T) {
+  const key = `mock:${name}`
+  // Stored fields win; fields added to the seed later still get defaults.
+  let value = Object.assign(seed() as object, storage.get<Partial<T>>(key)) as T
+
+  return {
+    get: () => value,
+    save(next: T) {
+      value = next
+      storage.set(key, value)
+      return value
+    },
+  }
+}
+
+/**
+ * A mock "table" persisted to localStorage so created/edited records survive
+ * reloads, like a real backend would. Clear site data to reset to the seed.
+ */
+export function createMockCollection<T extends { id: string }>(name: string, seed: () => T[]) {
+  const key = `mock:${name}`
+  let rows = storage.get<T[]>(key) ?? seed()
+
+  return {
+    all: () => rows,
+    find: (id: string) => rows.find((row) => row.id === id),
+    save(next: T[]) {
+      rows = next
+      storage.set(key, rows)
+    },
+  }
+}

package/template/src/core/api/rest.ts

@@ -0,0 +1,67 @@
+import { http } from './http'
+import type { ListParams, Paginated } from './types'
+
+export type CrudService<T, TInput, TFilters> = {
+  list(params: ListParams<TFilters>): Promise<Paginated<T>>
+  get(id: string): Promise<T>
+  create(input: TInput): Promise<T>
+  update(id: string, input: TInput): Promise<T>
+  remove(id: string): Promise<void>
+}
+
+type RawPage<T> = {
+  // Our shape
+  items?: T[]
+  total?: number
+  page?: number
+  pageSize?: number
+  // Laravel paginate(): flat, or under `meta` for API resources
+  data?: T[]
+  current_page?: number
+  per_page?: number
+  meta?: { total?: number; current_page?: number; per_page?: number }
+  // Spring Data Page (`number` is 0-based)
+  content?: T[]
+  totalElements?: number
+  number?: number
+  size?: number
+}
+
+/** Accepts our shape, Laravel pagination and Spring Data pages. Other shapes: map them in the service. */
+export function toPaginated<T>(raw: RawPage<T>, params: ListParams<unknown>): Paginated<T> {
+  const items = raw.items ?? raw.data ?? raw.content ?? []
+  return {
+    items,
+    total: raw.total ?? raw.meta?.total ?? raw.totalElements ?? items.length,
+    page: raw.page ?? raw.current_page ?? raw.meta?.current_page ?? (raw.number !== undefined ? raw.number + 1 : params.page),
+    pageSize: raw.pageSize ?? raw.per_page ?? raw.meta?.per_page ?? raw.size ?? params.pageSize,
+  }
+}
+
+/** Query string of every list request; the contract is in BACKEND.md. */
+export function toListQuery(params: ListParams<unknown>) {
+  return {
+    page: params.page,
+    pageSize: params.pageSize,
+    search: params.search,
+    sort: params.sort ? `${params.sort.field}.${params.sort.direction}` : undefined,
+    ...(params.filters as Record<string, string | undefined> | undefined),
+  }
+}
+
+/** Single records may arrive bare or wrapped in `{ data }` (Laravel API resources). */
+const unwrap = <T>(raw: T | { data: T }): T =>
+  raw !== null && typeof raw === 'object' && 'data' in raw ? raw.data : raw
+
+/** Standard REST resource: GET/POST `path`, GET/PUT/DELETE `path/:id`. */
+export function createRestService<T, TInput, TFilters>(path: string): CrudService<T, TInput, TFilters> {
+  return {
+    list: async (params) => toPaginated(await http.get<RawPage<T>>(path, { query: toListQuery(params) }), params),
+    get: async (id) => unwrap(await http.get<T | { data: T }>(`${path}/${id}`)),
+    create: async (input) => unwrap(await http.post<T | { data: T }>(path, input)),
+    update: async (id, input) => unwrap(await http.put<T | { data: T }>(`${path}/${id}`, input)),
+    remove: async (id) => {
+      await http.delete(`${path}/${id}`)
+    },
+  }
+}

package/template/src/core/api/types.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared shapes for list endpoints. Real backends (Spring Boot, Node) should
+ * map their responses into these in the service layer, so screens never change.
+ */
+export type SortDirection = 'asc' | 'desc'
+
+export type ListParams<TFilters = Record<string, string | undefined>> = {
+  /** 1-based page number. */
+  page: number
+  pageSize: number
+  search?: string
+  sort?: { field: string; direction: SortDirection }
+  filters?: TFilters
+}
+
+export type Paginated<T> = {
+  items: T[]
+  total: number
+  page: number
+  pageSize: number
+}

package/template/src/core/audit/audit.service.ts

@@ -0,0 +1,94 @@
+import { demoSeed } from '@/core/api/demo'
+import { createMockCollection, delay, paginate } from '@/core/api/mock'
+import type { ListParams, Paginated } from '@/core/api/types'
+import { authStore } from '@/core/auth/auth-store'
+
+/** Action ids map to `company:audit.actions.<id>`. */
+export const auditActions = [
+  'generalUpdated',
+  'brandingUpdated',
+  'securityUpdated',
+  'integrationUpdated',
+  'webhookCreated',
+  'webhookDeleted',
+  'apiKeyCreated',
+  'apiKeyRevoked',
+  'userInvited',
+  'inviteResent',
+  'roleChanged',
+  'userDeactivated',
+  'userReactivated',
+  'ownershipTransferred',
+] as const
+export type AuditAction = (typeof auditActions)[number]
+
+export type AuditEntry = {
+  id: string
+  at: string
+  actor: { id: string; name: string; email: string }
+  action: AuditAction
+  /** What was changed, e.g. a user's email or "SMTP". */
+  target?: string
+  detail?: Record<string, string>
+  ip: string
+}
+
+export type AuditFilters = {
+  actor?: string
+  action?: string
+  /** '24h' | '7d' | '30d'; empty = all time. */
+  range?: string
+}
+
+/**
+ * Who did what and when. A real backend writes audit entries server-side in
+ * the same transaction as the change; the mock services call record().
+ */
+export interface AuditService {
+  list(params: ListParams<AuditFilters>): Promise<Paginated<AuditEntry>>
+  /** Distinct actors for the user filter. */
+  actors(): Promise<AuditEntry['actor'][]>
+  record(action: AuditAction, target?: string, detail?: Record<string, string>): void
+}
+
+const rangeMs: Record<string, number> = { '24h': 86_400_000, '7d': 7 * 86_400_000, '30d': 30 * 86_400_000 }
+
+function createMockAuditService(): AuditService {
+  const db = createMockCollection('audit', () => demoSeed<() => AuditEntry[]>('audit')?.() ?? [])
+
+  return {
+    async list(params) {
+      await delay()
+      const { actor, action, range } = params.filters ?? {}
+      const since = range && rangeMs[range] ? Date.now() - rangeMs[range] : 0
+      const rows = db
+        .all()
+        .filter((e) => (!actor || e.actor.id === actor) && (!action || e.action === action) && new Date(e.at).getTime() >= since)
+        .map((e) => ({ ...e, actorName: e.actor.name }))
+      return paginate(rows, params, ['actorName', 'target'])
+    },
+
+    async actors() {
+      await delay(100, 200)
+      const map = new Map(db.all().map((e) => [e.actor.id, e.actor]))
+      return [...map.values()].sort((a, b) => a.name.localeCompare(b.name))
+    },
+
+    record(action, target, detail) {
+      const user = authStore.getSession()?.user
+      if (!user) return
+      const entry: AuditEntry = {
+        id: `a_${Date.now().toString(36)}`,
+        at: new Date().toISOString(),
+        actor: { id: user.id, name: `${user.firstName} ${user.lastName}`.trim() || user.email, email: user.email },
+        action,
+        target,
+        detail,
+        ip: '88.241.12.40',
+      }
+      db.save([entry, ...db.all()].slice(0, 500))
+    },
+  }
+}
+
+export const auditService: AuditService = createMockAuditService()

package/template/src/core/audit/hooks.ts

@@ -0,0 +1,19 @@
+import { keepPreviousData, useQuery } from '@tanstack/react-query'
+
+import type { ListParams } from '@/core/api/types'
+import { auditService, type AuditFilters } from './audit.service'
+
+/** Writes that record audit entries invalidate `auditKeys.all`. */
+export const auditKeys = {
+  all: ['audit'] as const,
+  list: (params: ListParams<AuditFilters>) => [...auditKeys.all, 'list', params] as const,
+  actors: () => [...auditKeys.all, 'actors'] as const,
+}
+
+export function useAuditLog(params: ListParams<AuditFilters>) {
+  return useQuery({ queryKey: auditKeys.list(params), queryFn: () => auditService.list(params), placeholderData: keepPreviousData })
+}
+
+export function useAuditActors() {
+  return useQuery({ queryKey: auditKeys.actors(), queryFn: () => auditService.actors() })
+}

package/template/src/core/auth/auth-store.ts

@@ -0,0 +1,52 @@
+import { storage } from '@/core/lib/storage'
+import { isRole } from './roles'
+import type { Session } from './types'
+
+const KEY = 'session'
+const listeners = new Set<() => void>()
+
+function read(): Session | null {
+  const session = storage.get<Session>(KEY)
+  // Drop expired sessions and ones saved by an older app version.
+  if (session && (session.expiresAt < Date.now() || !isRole(session.user?.role) || typeof session.user.firstName !== 'string')) {
+    storage.remove(KEY)
+    return null
+  }
+  return session
+}
+
+let current = read()
+
+function emit() {
+  for (const l of listeners) l()
+}
+
+/**
+ * The persisted session (localStorage). Framework-agnostic so the HTTP client
+ * can read the token and clear it on 401 without React.
+ */
+export const authStore = {
+  getSession: () => current,
+  set(session: Session) {
+    current = session
+    storage.set(KEY, session)
+    emit()
+  },
+  clear() {
+    current = null
+    storage.remove(KEY)
+    emit()
+  },
+  subscribe(listener: () => void) {
+    listeners.add(listener)
+    return () => listeners.delete(listener)
+  },
+}
+
+// Keep tabs in sync (sign out in one tab signs out everywhere).
+window.addEventListener('storage', (e) => {
+  if (e.key?.endsWith(KEY)) {
+    current = read()
+    emit()
+  }
+})

package/template/src/core/auth/auth.service.ts

@@ -0,0 +1,86 @@
+import { ApiError, http } from '@/core/api/http'
+import { delay } from '@/core/api/mock'
+import { authMode, csrfUrl, isDemo } from '@/core/config/runtime'
+import type { User } from '@/core/users/types'
+import { findUserByEmail, userErrors, usersService } from '@/core/users/users.service'
+import { authStore } from './auth-store'
+import { localCredentials } from './local-credentials'
+import type { AuthService, Session } from './types'
+
+const SESSION_TTL = 1000 * 60 * 60 * 24 * 7 // 7 days
+export function startLocalSession(user: User): Session {
+  const session: Session = {
+    user: { ...user, lastActiveAt: new Date().toISOString() },
+    token: `mock.${user.id}.${Date.now().toString(36)}`,
+    expiresAt: Date.now() + SESSION_TTL,
+  }
+  authStore.set(session)
+  return session
+}
+
+/**
+ * No backend yet. In the public demo any password works: a known email signs in as
+ * that user, an unknown one as the Owner. In a real install the password from the
+ * setup wizard is checked (see local-credentials: this browser only, not security).
+ */
+const mockAuthService: AuthService = {
+  async login({ email, password }) {
+    await delay(400, 700)
+    if (isDemo) {
+      const users = await usersService.listActive()
+      const user = (await findUserByEmail(email)) ?? users.find((u) => u.role === 'owner')
+      if (!user) throw new ApiError(404, userErrors.inactive)
+      if (user.status !== 'active') throw new ApiError(403, userErrors.inactive)
+      return startLocalSession(user)
+    }
+    const user = await findUserByEmail(email)
+    if (!user || !(await localCredentials.verify(user.id, password))) throw new ApiError(401, 'invalid_credentials')
+    if (user.status !== 'active') throw new ApiError(403, userErrors.inactive)
+    return startLocalSession(user)
+  },
+
+  async logout() {
+    authStore.clear()
+  },
+
+  async switchRole(role) {
+    const users = await usersService.listActive()
+    const current = authStore.getSession()?.user
+    // Project-defined roles have no seeded demo user: keep the identity, change the role.
+    const user = users.find((u) => u.role === role) ?? (current && { ...current, role })
+    if (!user) throw new ApiError(404, userErrors.inactive)
+    return startLocalSession(user)
+  },
+}
+
+export type AuthResponse = { user: User; token?: string; expiresAt?: number }
+
+/** Cookie mode: the server sets the XSRF cookie before the first write. */
+export async function fetchCsrfCookie() {
+  if (authMode === 'cookie' && csrfUrl) await fetch(csrfUrl, { credentials: 'include' })
+}
+
+/** Real backend (bearer or cookie mode); the contract is in BACKEND.md. */
+const restAuthService: AuthService = {
+  async login(credentials) {
+    await fetchCsrfCookie()
+    const { user, token, expiresAt } = await http.post<AuthResponse>('/auth/login', credentials)
+    const session: Session = { user, token, expiresAt: expiresAt ?? Date.now() + SESSION_TTL }
+    authStore.set(session)
+    return session
+  },
+
+  async logout() {
+    try {
+      await http.post('/auth/logout')
+    } finally {
+      authStore.clear()
+    }
+  },
+
+  async switchRole() {
+    throw new ApiError(400, 'not_available')
+  },
+}
+
+export const authService: AuthService = authMode === 'mock' ? mockAuthService : restAuthService

package/template/src/core/auth/can.tsx

@@ -0,0 +1,39 @@
+import { useCallback, type ReactNode } from 'react'
+
+import { hasPermission, type Permission } from './permissions'
+import { useSession } from './use-auth'
+
+/**
+ * Permission checks for the current user. UI convenience only — the backend
+ * must enforce the same permissions (see permissions.ts).
+ */
+// eslint-disable-next-line react/only-export-components
+export function usePermissions() {
+  const role = useSession()?.user.role
+  const can = useCallback((permission: Permission) => hasPermission(role, permission), [role])
+  return { role, can }
+}
+
+// eslint-disable-next-line react/only-export-components
+export function useCan(permission: Permission) {
+  return usePermissions().can(permission)
+}
+
+/**
+ * Hide or disable UI by permission.
+ *   <Can permission="products.create"><ButtonLink …/></Can>          hides
+ *   <Can permission="products.delete">{(allowed) => <Button disabled={!allowed} />}</Can>
+ */
+export function Can({
+  permission,
+  children,
+  fallback = null,
+}: {
+  permission: Permission
+  children: ReactNode | ((allowed: boolean) => ReactNode)
+  fallback?: ReactNode
+}) {
+  const allowed = useCan(permission)
+  if (typeof children === 'function') return children(allowed)
+  return allowed ? children : fallback
+}