@asteby/metacore-runtime-react 39.3.0 → 42.0.0

package/src/index.ts

@@ -129,6 +129,28 @@ export {
     type UseDynamicFiltersResult,
 } from './use-dynamic-filters'
 export { useDebouncedValue, SEARCH_DEBOUNCE_MS } from './use-debounced-value'
+export {
+    useOptimisticMutation,
+    type UseOptimisticMutationOptions,
+    type UseOptimisticMutationResult,
+} from './use-optimistic-mutation'
+export { useFlipAnimation, type UseFlipAnimationOptions } from './use-flip-animation'
+export {
+    usePersistedQuery,
+    createPersistedSnapshot,
+    type UsePersistedQueryOptions,
+    type PersistedSnapshot,
+    type PersistedSnapshotOptions,
+    type PersistedEntry,
+} from './use-persisted-query'
+export {
+    motionDuration,
+    motionEasing,
+    prefersReducedMotion,
+    MOTION_DEFAULTS,
+    type MotionDuration,
+    type MotionEasing,
+} from './motion'
 export {
     useResource,
     useMutation,
@@ -385,6 +407,19 @@ export {
     type ModelExtension,
     type ModelExtensionProps,
 } from './model-extension-registry'
+export {
+    registerAgentResultRenderer,
+    resolveAgentResultRenderer,
+    listAgentResultRenderers,
+    clearAgentResultRenderers,
+    useAgentResultRegistryVersion,
+    AgentResultView,
+    type AgentResult,
+    type AgentResultRenderer,
+    type AgentResultRendererOptions,
+    type AgentResultRendererProps,
+    type AgentResultViewProps,
+} from './agent-result-registry'
 export {
     isColumnVisibleInTable,
     isColumnVisibleInModal,

package/src/motion.ts

@@ -0,0 +1,47 @@
+/**
+ * Runtime access to the theme's motion tokens (`--motion-duration-*`,
+ * `--motion-ease-*` from @asteby/metacore-theme/tokens.css). Hosts that do
+ * not ship those variables get the same defaults, so JS-driven animations
+ * (WAAPI, dnd-kit) and CSS transitions stay on one scale.
+ */
+export type MotionDuration = 'instant' | 'fast' | 'moderate' | 'slow'
+export type MotionEasing = 'standard' | 'emphasized' | 'exit'
+
+export const MOTION_DEFAULTS = {
+  duration: { instant: 100, fast: 150, moderate: 220, slow: 320 } as Record<MotionDuration, number>,
+  easing: {
+    standard: 'cubic-bezier(0.2, 0, 0, 1)',
+    emphasized: 'cubic-bezier(0.3, 0, 0, 1)',
+    exit: 'cubic-bezier(0.4, 0, 1, 1)',
+  } as Record<MotionEasing, string>,
+}
+
+function cssVar(name: string): string {
+  if (typeof document === 'undefined' || typeof getComputedStyle !== 'function') return ''
+  return getComputedStyle(document.documentElement).getPropertyValue(name).trim()
+}
+
+/** True when the user asked the OS for reduced motion. */
+export function prefersReducedMotion(): boolean {
+  return (
+    typeof window !== 'undefined' &&
+    typeof window.matchMedia === 'function' &&
+    window.matchMedia('(prefers-reduced-motion: reduce)').matches
+  )
+}
+
+/** Duration token in ms (0 under prefers-reduced-motion). */
+export function motionDuration(token: MotionDuration): number {
+  if (prefersReducedMotion()) return 0
+  const raw = cssVar(`--motion-duration-${token}`)
+  if (raw) {
+    const n = parseFloat(raw)
+    if (Number.isFinite(n)) return raw.endsWith('ms') || !raw.endsWith('s') ? n : n * 1000
+  }
+  return MOTION_DEFAULTS.duration[token]
+}
+
+/** Easing token as a CSS timing function. */
+export function motionEasing(token: MotionEasing): string {
+  return cssVar(`--motion-ease-${token}`) || MOTION_DEFAULTS.easing[token]
+}

package/src/use-flip-animation.ts

@@ -0,0 +1,157 @@
+import { useEffect, useLayoutEffect, useRef, type RefObject } from 'react'
+import {
+  motionDuration,
+  motionEasing,
+  prefersReducedMotion,
+  type MotionDuration,
+  type MotionEasing,
+} from './motion'
+
+export interface UseFlipAnimationOptions {
+  /** Elements to animate, queried inside the root. */
+  selector?: string
+  /** Stable identity of an element across renders. Default: data-flip-key, then href, then text. */
+  keyOf?: (el: HTMLElement) => string | null
+  /**
+   * Scroll container used as the coordinate origin, so scrolling between two
+   * snapshots does not read as movement. Default: the root.
+   */
+  scrollContainer?: (root: HTMLElement) => HTMLElement | null
+  /** Motion token (default `moderate`) or explicit ms. */
+  duration?: MotionDuration | number
+  /** Motion token (default `standard`) or a CSS timing function. */
+  easing?: MotionEasing | string
+  /** Off switch; the hook also stays still under prefers-reduced-motion. */
+  disabled?: boolean
+}
+
+const DEFAULT_SELECTOR = '[data-flip-key]'
+const MOTION_EASING_KEYS = { standard: 1, emphasized: 1, exit: 1 }
+
+const defaultKeyOf = (el: HTMLElement): string | null =>
+  el.dataset.flipKey ?? el.getAttribute('href') ?? (el.textContent?.trim() || null)
+
+type Positions = Map<string, { top: number; left: number }>
+
+/**
+ * FLIP reorder animation: when `trigger` changes, elements that exist before
+ * and after the change glide from their old position to the new one.
+ *
+ * Positions are snapshotted when the list is at rest (after mount, after each
+ * animation, and after pointer interaction inside the root), never in the
+ * render path, so a re-render costs nothing. Uses the Web Animations API on
+ * `transform` only; with prefers-reduced-motion the change is instant.
+ */
+export function useFlipAnimation(
+  rootRef: RefObject<HTMLElement | null>,
+  trigger: unknown,
+  options: UseFlipAnimationOptions = {},
+): void {
+  const {
+    selector = DEFAULT_SELECTOR,
+    keyOf = defaultKeyOf,
+    scrollContainer,
+    duration = 'moderate',
+    easing = 'standard',
+    disabled = false,
+  } = options
+  const positionsRef = useRef<Positions | null>(null)
+  const triggerRef = useRef(trigger)
+  const configRef = useRef({ selector, keyOf, scrollContainer })
+  useEffect(() => {
+    configRef.current = { selector, keyOf, scrollContainer }
+  })
+
+  const measure = (): Positions | null => {
+    const root = rootRef.current
+    if (!root) return null
+    const { selector: sel, keyOf: key, scrollContainer: sc } = configRef.current
+    const origin = (sc ? sc(root) : null) ?? root
+    const box = origin.getBoundingClientRect()
+    const out: Positions = new Map()
+    root.querySelectorAll<HTMLElement>(sel).forEach((el) => {
+      const k = key(el)
+      if (!k || out.has(k)) return
+      const r = el.getBoundingClientRect()
+      if (r.width === 0 && r.height === 0) return
+      out.set(k, {
+        top: r.top - box.top + origin.scrollTop,
+        left: r.left - box.left + origin.scrollLeft,
+      })
+    })
+    return out
+  }
+  const measureRef = useRef(measure)
+  useEffect(() => {
+    measureRef.current = measure
+  })
+
+  // Snapshot at rest: after mount and after interactions that move things
+  // without a trigger change (expanding a collapsible, for instance).
+  // Listens on the document and resolves the root per event, so a ref whose
+  // element is swapped (remount, mobile sheet) keeps working.
+  useEffect(() => {
+    let timer: ReturnType<typeof setTimeout> | null = null
+    const schedule = () => {
+      if (timer) clearTimeout(timer)
+      timer = setTimeout(() => {
+        positionsRef.current = measureRef.current()
+      }, 350)
+    }
+    const onInteraction = (e: Event) => {
+      const root = rootRef.current
+      if (root && e.target instanceof Node && root.contains(e.target)) schedule()
+    }
+    schedule()
+    document.addEventListener('pointerup', onInteraction, true)
+    document.addEventListener('keyup', onInteraction, true)
+    window.addEventListener('resize', schedule)
+    return () => {
+      if (timer) clearTimeout(timer)
+      document.removeEventListener('pointerup', onInteraction, true)
+      document.removeEventListener('keyup', onInteraction, true)
+      window.removeEventListener('resize', schedule)
+    }
+  }, [rootRef])
+
+  useLayoutEffect(() => {
+    if (Object.is(triggerRef.current, trigger)) return
+    triggerRef.current = trigger
+    const before = positionsRef.current
+    const root = rootRef.current
+    if (!root) return
+    const after = measureRef.current()
+    positionsRef.current = after
+    if (!before || !after || disabled || prefersReducedMotion()) return
+    const durationMs = typeof duration === 'number' ? duration : motionDuration(duration)
+    if (durationMs <= 0) return
+    const timing = easing in MOTION_EASING_KEYS ? motionEasing(easing as MotionEasing) : easing
+
+    const { selector: sel, keyOf: key } = configRef.current
+    // A stale snapshot can report huge jumps; those would read as a glitch.
+    const maxJump = root.clientHeight > 0 ? root.clientHeight * 1.5 : Infinity
+    root.querySelectorAll<HTMLElement>(sel).forEach((el) => {
+      const k = key(el)
+      if (!k) return
+      const from = before.get(k)
+      const to = after.get(k)
+      if (!to || typeof el.animate !== 'function') return
+      if (!from) {
+        // Entered with this change: fade in instead of popping.
+        el.animate([{ opacity: 0 }, { opacity: 1 }], { duration: durationMs, easing: timing })
+        return
+      }
+      const dy = from.top - to.top
+      const dx = from.left - to.left
+      if (Math.abs(dy) < 1 && Math.abs(dx) < 1) return
+      if (Math.abs(dy) > maxJump) return
+      el.animate(
+        [
+          { transform: `translate(${dx}px, ${dy}px)` },
+          { transform: 'translate(0, 0)' },
+        ],
+        { duration: durationMs, easing: timing },
+      )
+    })
+  }, [trigger, rootRef, disabled, duration, easing])
+}

package/src/use-optimistic-mutation.ts

@@ -0,0 +1,218 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  useMutation,
+  useQueryClient,
+  type QueryKey,
+} from '@tanstack/react-query'
+
+export interface UseOptimisticMutationOptions<TData, TVariables, TCache> {
+  /** Query whose cached value the mutation changes. */
+  queryKey: QueryKey
+  mutationFn: (variables: TVariables) => Promise<TData>
+  /**
+   * Cache value to show while the request is in flight. Runs synchronously on
+   * `mutate`, so the UI repaints on the same frame as the click. Return
+   * `undefined` to leave the cache untouched.
+   */
+  optimistic: (current: TCache | undefined, variables: TVariables) => TCache | undefined
+  /**
+   * Cache value once the server confirms. Write/apply endpoints that return
+   * the resulting resource should map it here, so nothing is refetched.
+   * Default: keep the optimistic value.
+   */
+  reconcile?: (data: TData, variables: TVariables, current: TCache | undefined) => TCache | undefined
+  /**
+   * Coalesce bursts (drag and drop, sliders): the cache updates on every
+   * call, and only the last variables are sent once `debounceMs` pass
+   * without a new call. Pending work is flushed on unmount.
+   */
+  debounceMs?: number
+  /**
+   * A call equal to the one already in flight is ignored (double clicks).
+   * Default: structural equality via JSON.
+   */
+  isEqual?: (a: TVariables, b: TVariables) => boolean
+  /** Other queries to refresh in the background after a confirmed write. */
+  invalidate?: QueryKey[]
+  onSuccess?: (data: TData, variables: TVariables) => void
+  /**
+   * Runs after the cache was rolled back to the last confirmed value. Only
+   * the latest call reports: a superseded write that fails stays silent.
+   */
+  onError?: (error: unknown, variables: TVariables) => void
+}
+
+export interface UseOptimisticMutationResult<TVariables> {
+  /** Apply optimistically and persist. Safe to call repeatedly. */
+  mutate: (variables: TVariables) => void
+  /** True from the first `mutate` until the last one settles. */
+  isPending: boolean
+  /** Variables of the latest unconfirmed call (e.g. which card is applying). */
+  pendingVariables: TVariables | undefined
+  error: unknown
+  /** Re-send the variables of the last call that failed (toast "Reintentar"). */
+  retry: () => void
+}
+
+type Envelope<TVariables> = { variables: TVariables; seq: number }
+
+const jsonEqual = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
+
+/**
+ * Optimistic write over a TanStack Query cache entry, with rollback.
+ *
+ * ```tsx
+ * const apply = useOptimisticMutation({
+ *   queryKey: ['org-sidebar-layout'],
+ *   mutationFn: (key: string) => api.post('/apply', { key }).then((r) => r.data),
+ *   optimistic: (current, key) => ({ ...current, template_key: key }),
+ *   reconcile: (server) => server,
+ *   onError: (_e, key) => toast.error('No se aplicó', {
+ *     action: { label: 'Reintentar', onClick: () => apply.mutate(key) },
+ *   }),
+ * })
+ * <Card aria-busy={apply.pendingVariables === tpl.key} onClick={() => apply.mutate(tpl.key)} />
+ * ```
+ *
+ * - The cache is patched before the request, so the screen answers at once.
+ * - Writes to the same `queryKey` run one at a time, in call order (mutation
+ *   `scope`), so the last click is the last write the server sees.
+ * - Only the latest call decides what the cache shows: an older response
+ *   never overwrites a newer optimistic value. If the latest call fails, the
+ *   cache returns to the last value the server confirmed.
+ */
+export function useOptimisticMutation<TData, TVariables, TCache = TData>(
+  options: UseOptimisticMutationOptions<TData, TVariables, TCache>,
+): UseOptimisticMutationResult<TVariables> {
+  const qc = useQueryClient()
+  const optionsRef = useRef(options)
+  useEffect(() => {
+    optionsRef.current = options
+  })
+
+  const seqRef = useRef(0)
+  // Last value the server confirmed, captured before the first unconfirmed
+  // optimistic write. Null while nothing is in flight.
+  const confirmedRef = useRef<{ value: TCache | undefined } | null>(null)
+  const inFlightRef = useRef<TVariables | undefined>(undefined)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const queuedRef = useRef<Envelope<TVariables> | null>(null)
+  const [pendingVariables, setPendingVariables] = useState<TVariables | undefined>(undefined)
+  const [error, setError] = useState<unknown>(null)
+  const failedRef = useRef<{ variables: TVariables } | null>(null)
+
+  const scopeId = `optimistic:${JSON.stringify(options.queryKey)}`
+
+  const settleLatest = useCallback(() => {
+    confirmedRef.current = null
+    inFlightRef.current = undefined
+    setPendingVariables(undefined)
+  }, [])
+
+  const mutation = useMutation<TData, unknown, Envelope<TVariables>>({
+    scope: { id: scopeId },
+    mutationFn: ({ variables }) => optionsRef.current.mutationFn(variables),
+    onSuccess: (data, { variables, seq }) => {
+      const opts = optionsRef.current
+      const latest = seq === seqRef.current && queuedRef.current === null
+      if (latest) {
+        const current = qc.getQueryData<TCache>(opts.queryKey)
+        const next = opts.reconcile ? opts.reconcile(data, variables, current) : current
+        if (next !== undefined) qc.setQueryData<TCache>(opts.queryKey, next)
+        settleLatest()
+        setError(null)
+        for (const key of opts.invalidate ?? []) void qc.invalidateQueries({ queryKey: key })
+      } else if (confirmedRef.current) {
+        // A newer call owns the screen; only move the rollback point forward.
+        const base = confirmedRef.current.value
+        const next = opts.reconcile
+          ? opts.reconcile(data, variables, base)
+          : opts.optimistic(base, variables)
+        confirmedRef.current = { value: next ?? base }
+      }
+      opts.onSuccess?.(data, variables)
+    },
+    onError: (err, { variables, seq }) => {
+      const opts = optionsRef.current
+      const latest = seq === seqRef.current && queuedRef.current === null
+      // A superseded write that fails is moot: the newer call decides what
+      // the screen shows and whether the user sees an error.
+      if (!latest) return
+      const confirmed = confirmedRef.current
+      if (confirmed && confirmed.value !== undefined) {
+        qc.setQueryData<TCache>(opts.queryKey, confirmed.value)
+      }
+      settleLatest()
+      // The server may have partially applied; resync in the background.
+      void qc.invalidateQueries({ queryKey: opts.queryKey, exact: true })
+      failedRef.current = { variables }
+      setError(err)
+      opts.onError?.(err, variables)
+    },
+  })
+
+  const mutateRef = useRef(mutation.mutate)
+  useEffect(() => {
+    mutateRef.current = mutation.mutate
+  })
+
+  const send = useCallback((envelope: Envelope<TVariables>) => {
+    inFlightRef.current = envelope.variables
+    mutateRef.current(envelope)
+  }, [])
+
+  const flush = useCallback(() => {
+    if (timerRef.current) clearTimeout(timerRef.current)
+    timerRef.current = null
+    const queued = queuedRef.current
+    queuedRef.current = null
+    if (queued) send(queued)
+  }, [send])
+
+  const mutate = useCallback(
+    (variables: TVariables) => {
+      const opts = optionsRef.current
+      const isEqual = opts.isEqual ?? jsonEqual
+      const latestPending = queuedRef.current?.variables ?? inFlightRef.current
+      if (latestPending !== undefined && isEqual(latestPending, variables)) return
+
+      const seq = ++seqRef.current
+      if (!confirmedRef.current) {
+        confirmedRef.current = { value: qc.getQueryData<TCache>(opts.queryKey) }
+      }
+      // A refetch landing mid-write would paint the old value back.
+      void qc.cancelQueries({ queryKey: opts.queryKey, exact: true })
+      const next = opts.optimistic(qc.getQueryData<TCache>(opts.queryKey), variables)
+      if (next !== undefined) qc.setQueryData<TCache>(opts.queryKey, next)
+      setPendingVariables(variables)
+      setError(null)
+      failedRef.current = null
+
+      const envelope = { variables, seq }
+      if (opts.debounceMs && opts.debounceMs > 0) {
+        queuedRef.current = envelope
+        if (timerRef.current) clearTimeout(timerRef.current)
+        timerRef.current = setTimeout(flush, opts.debounceMs)
+        return
+      }
+      send(envelope)
+    },
+    [qc, flush, send],
+  )
+
+  // Never drop a debounced write because the editor closed.
+  useEffect(() => flush, [flush])
+
+  const retry = useCallback(() => {
+    const failed = failedRef.current
+    if (failed) mutate(failed.variables)
+  }, [mutate])
+
+  return {
+    mutate,
+    isPending: pendingVariables !== undefined,
+    pendingVariables,
+    error,
+    retry,
+  }
+}

package/src/use-persisted-query.ts

@@ -0,0 +1,152 @@
+import { useEffect, useMemo } from 'react'
+import {
+  useQuery,
+  useQueryClient,
+  type QueryKey,
+  type UseQueryOptions,
+  type UseQueryResult,
+} from '@tanstack/react-query'
+
+/**
+ * A versioned, scoped copy of a value in localStorage. Shell data that decides
+ * the first paint (navigation, the org's menu layout, installed presets,
+ * permissions) is read from here synchronously, so a reload paints the last
+ * known state instead of a default that reorders when the network answers.
+ *
+ * The entry lives under `<key>:v<version>:<scope>`. Bump `version` when the
+ * stored shape changes; old entries are simply never read again. `scope` keeps
+ * one org or user from seeing another's copy on a shared browser.
+ */
+export interface PersistedSnapshotOptions {
+  key: string
+  version: number
+  /** Entries older than this are ignored (default: 30 days). */
+  maxAgeMs?: number
+}
+
+export interface PersistedEntry<T> {
+  data: T
+  /** When the data was fetched (ms epoch). */
+  ts: number
+}
+
+export interface PersistedSnapshot<T> {
+  read(scope: string): PersistedEntry<T> | undefined
+  write(scope: string, data: T, meta?: { ts?: number }): void
+  clear(scope: string): void
+}
+
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000
+
+function storage(): Storage | null {
+  try {
+    return typeof localStorage === 'undefined' ? null : localStorage
+  } catch {
+    return null
+  }
+}
+
+export function createPersistedSnapshot<T>({
+  key,
+  version,
+  maxAgeMs = DEFAULT_MAX_AGE_MS,
+}: PersistedSnapshotOptions): PersistedSnapshot<T> {
+  const slot = (scope: string) => `${key}:v${version}:${scope}`
+  return {
+    read(scope) {
+      const s = storage()
+      if (!s) return undefined
+      try {
+        const raw = s.getItem(slot(scope))
+        if (!raw) return undefined
+        const parsed = JSON.parse(raw) as Partial<PersistedEntry<T>>
+        if (typeof parsed?.ts !== 'number' || !('data' in parsed)) return undefined
+        if (Date.now() - parsed.ts > maxAgeMs) return undefined
+        return { data: parsed.data as T, ts: parsed.ts }
+      } catch {
+        return undefined
+      }
+    },
+    write(scope, data, { ts = Date.now() } = {}) {
+      try {
+        storage()?.setItem(slot(scope), JSON.stringify({ data, ts }))
+      } catch {
+        // quota / private mode: the snapshot is an optimization, never fatal
+      }
+    },
+    clear(scope) {
+      try {
+        storage()?.removeItem(slot(scope))
+      } catch {
+        /* ignore */
+      }
+    },
+  }
+}
+
+export type UsePersistedQueryOptions<TQueryFnData, TData, TQueryKey extends QueryKey> = UseQueryOptions<
+  TQueryFnData,
+  Error,
+  TData,
+  TQueryKey
+> & {
+  persist: {
+    snapshot: PersistedSnapshot<TQueryFnData>
+    /**
+     * Org/user the data belongs to. Without a scope nothing is read or
+     * written (e.g. before sign-in).
+     */
+    scope: string | null | undefined
+  }
+}
+
+/**
+ * `useQuery` seeded from a {@link PersistedSnapshot}: the first render already
+ * has the last fetched value (stale-while-revalidate), and every later value —
+ * a refetch, or a `setQueryData` from a mutation — is written back. The seed is
+ * stale from the start: every page load revalidates it once in the background,
+ * so a change made elsewhere (a plantilla applied, an addon installed,
+ * permissions edited) shows on the next load even inside `staleTime`.
+ *
+ * Persist the raw server payload and derive UI shapes with `select`; the
+ * snapshot must be JSON.
+ */
+export function usePersistedQuery<
+  TQueryFnData,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UsePersistedQueryOptions<TQueryFnData, TData, TQueryKey>,
+): UseQueryResult<TData, Error> {
+  const { persist, ...queryOptions } = options
+  const { snapshot, scope } = persist
+  const seed = useMemo(
+    () => (scope ? snapshot.read(scope) : undefined),
+    [snapshot, scope],
+  )
+  const query = useQuery<TQueryFnData, Error, TData, TQueryKey>({
+    ...queryOptions,
+    ...(seed && queryOptions.initialData === undefined
+      ? { initialData: seed.data, initialDataUpdatedAt: 0 }
+      : {}),
+  } as UseQueryOptions<TQueryFnData, Error, TData, TQueryKey>)
+
+  const queryClient = useQueryClient()
+  const { dataUpdatedAt, status, isPlaceholderData } = query
+  const queryKey = queryOptions.queryKey
+  useEffect(() => {
+    if (!scope || status !== 'success' || isPlaceholderData) return
+    // Still the seed: nothing new to store.
+    if (dataUpdatedAt === 0) return
+    // `query.data` is the selected shape; persist the raw cache value.
+    const raw = queryClient.getQueryData<TQueryFnData>(queryKey)
+    if (raw === undefined) return
+    snapshot.write(scope, raw, { ts: dataUpdatedAt })
+    // queryKey is compared by react-query's hash, not identity: a new array
+    // each render must not rewrite the snapshot.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [queryClient, scope, snapshot, seed, status, isPlaceholderData, dataUpdatedAt])
+
+  return query
+}
+

package/tsconfig.json

@@ -13,5 +13,5 @@
     "rootDir": "./src"
   },
   "include": ["src/**/*"],
-  "exclude": ["src/**/*.test.ts", "src/**/__tests__/**"]
+  "exclude": ["src/**/*.test.ts", "src/**/*.test.tsx", "src/**/__tests__/**"]
 }