@startsimpli/integrations 0.2.25 → 0.2.27

package/src/components/pages/PlanningPage.tsx

@@ -0,0 +1,691 @@
+/**
+ * PLANNING — what this team is trying to achieve, and what is outstanding under
+ * each of those things (bd startsim-8l6ef).
+ *
+ * `<PlanningPage api={planningApi} scope={scope} />`, the same injected shape as
+ * `ConnectionsPage`, `LibraryPage`, `AskPage` and `TrackerPage`. The app owns a
+ * wrapper and className slots; nothing here imports a provider or fetches by
+ * itself.
+ *
+ * THE RELATIONSHIP TO THE TRACKER, stated because getting it wrong is the whole
+ * risk of adding a second screen. There is ONE list of items and two views over
+ * it. The tracker asks "what came out of my meetings and is still owed" and owns
+ * the extraction machinery. This asks "what are we trying to achieve, and what
+ * is under it" and owns the focus tree. The item row, the honesty banner and the
+ * overdue/changed predicates are SHARED — lifted into `./work-items` before this
+ * file existed, precisely so the two screens cannot drift into disagreeing about
+ * what "overdue" means.
+ *
+ * WHAT IT LETS A PERSON DO that the tracker cannot: create a focus, create an
+ * item, file an existing item under a focus, and set an owner from the
+ * workspace's REAL members. That last one is what closes the free-text-owner gap
+ * (bd startsim-768w.38.29) — and it is ADDITIVE, because on a real tenant most
+ * people named in the material are not members, so the typed name survives
+ * beside the resolved one.
+ *
+ * NOTHING ON THIS SCREEN WRITES `progress` FROM AN EFFECT. A focus's standing is
+ * read as counts and rendered; the stored `progress` field is set by a person or
+ * by an explicit recalculation. A render that recomputed and PATCHed would be
+ * the loop recorded on `TrackerPageProps.now`, which cost 917 requests in ten
+ * minutes on a live tenant — with a write on every pass.
+ */
+import * as React from 'react';
+
+import { displayProgress } from '../../corpus/planning';
+import {
+  UnfilteredNotice,
+  WorkItemRow,
+  compareForScreen,
+  failureMessage,
+  isOverdue,
+} from './work-items';
+import type {
+  AuthoredItem,
+  Commitment,
+  CommitmentQuery,
+  CommitmentStatus,
+  CorpusScope,
+  Focus,
+  FocusDraft,
+  FocusStanding,
+  FocusStatus,
+  PlanningApi,
+} from '../../corpus/types';
+
+type PlanningSlot =
+  | 'root' | 'section' | 'heading' | 'card' | 'badge' | 'button' | 'secondaryButton'
+  | 'input' | 'muted' | 'error' | 'warning' | 'row' | 'due' | 'progressTrack' | 'progressBar';
+
+const DEFAULTS: Record<PlanningSlot, string> = {
+  root: 'space-y-6',
+  section: 'space-y-3',
+  heading: 'text-lg font-semibold text-gray-900',
+  card: 'rounded-lg border border-gray-200 p-4',
+  badge: 'inline-flex items-center rounded-full border border-gray-300 px-2 py-0.5 text-xs text-gray-700',
+  button: 'rounded-md bg-gray-900 px-3 py-1.5 text-sm font-medium text-white disabled:opacity-50',
+  secondaryButton: 'rounded-md border border-gray-300 px-3 py-1.5 text-sm font-medium text-gray-800 disabled:opacity-50',
+  input: 'rounded-md border border-gray-300 px-3 py-1.5 text-sm',
+  muted: 'text-sm text-gray-500',
+  error: 'text-sm text-red-600',
+  warning: 'rounded-md border border-amber-300 bg-amber-50 p-3 text-sm text-amber-900',
+  row: 'rounded-lg border border-gray-200 p-4',
+  due: 'text-sm font-medium text-red-700',
+  progressTrack: 'h-2 w-full overflow-hidden rounded-full bg-gray-200',
+  progressBar: 'h-2 rounded-full bg-gray-900 transition-all',
+};
+
+/** Which filters this screen asks for, and therefore owes a confession about. */
+const PLANNING_FILTER_KEYS = ['status', 'owner', 'dueBefore', 'focus'] as const;
+
+const FOCUS_STATUS_OPTIONS: FocusStatus[] = [
+  'draft', 'active', 'on_track', 'at_risk', 'off_track', 'completed', 'cancelled',
+];
+
+/** `CommitmentSubtype` is a string on purpose, so this list is a convenience
+ *  rather than a constraint — `requirement` costs nothing to add because of it. */
+const SUBTYPE_OPTIONS = ['action', 'requirement', 'decision', 'need', 'risk', 'question'];
+
+const PRIORITY_OPTIONS = [
+  { value: 0, label: 'Critical' }, { value: 1, label: 'High' },
+  { value: 2, label: 'Medium' }, { value: 3, label: 'Low' }, { value: 4, label: 'Backlog' },
+];
+
+/**
+ * How many focus standings are fetched at once.
+ *
+ * Each one is three count-only reads, so a workspace with forty focuses is a
+ * hundred and twenty requests if they all go at once. Bounded rather than
+ * unbounded for the same reason the corpus graph read is: the tenant data API
+ * pays for every one of them.
+ */
+const STANDING_CONCURRENCY = 4;
+
+export interface PlanningPageProps {
+  api: PlanningApi;
+  scope: CorpusScope;
+  /** Click-through from a mention to the record, normally the Library route. */
+  onOpenDocument?: (documentId: string) => void;
+  /**
+   * Injectable clock, so "overdue" is testable.
+   *
+   * NOT DEFAULTED IN THE SIGNATURE, for the reason spelled out on
+   * `TrackerPageProps.now`: `Date.now()` in a default parameter is a new value
+   * on every render, which makes every memo below it new, which fires the load
+   * effect, which sets state, which renders.
+   */
+  now?: number;
+  classNames?: Partial<Record<PlanningSlot, string>>;
+}
+
+export function PlanningPage({
+  api, scope, onOpenDocument, now, classNames = {},
+}: PlanningPageProps) {
+  const cn = { ...DEFAULTS, ...classNames };
+
+  // Frozen once. See the note on the prop.
+  const [mountedAt] = React.useState(() => Date.now());
+  const clock = now ?? mountedAt;
+
+  // The api is an injected CAPABILITY, not data, so its identity is not a reason
+  // to re-read. Held in a ref and read at call time.
+  const apiRef = React.useRef(api);
+  apiRef.current = api;
+
+  const [focuses, setFocuses] = React.useState<Focus[]>([]);
+  const [standings, setStandings] = React.useState<Record<string, FocusStanding>>({});
+  const [selected, setSelected] = React.useState<string | null>(null);
+  const [items, setItems] = React.useState<Commitment[]>([]);
+  const [applied, setApplied] = React.useState<string[]>([]);
+  const [members, setMembers] = React.useState<Array<{ sub: string; email: string; name?: string }>>([]);
+  const [showDone, setShowDone] = React.useState(false);
+  const [owner, setOwner] = React.useState('');
+  const [loadingFocuses, setLoadingFocuses] = React.useState(true);
+  const [loadingItems, setLoadingItems] = React.useState(false);
+  const [error, setError] = React.useState('');
+  const [epoch, setEpoch] = React.useState(0);
+
+  const canAuthor = Boolean(api.createCommitment && api.createFocus);
+
+  // -- focuses -------------------------------------------------------------
+
+  const loadFocuses = React.useCallback(async () => {
+    setLoadingFocuses(true);
+    setError('');
+    try {
+      // Worst-off first, from the SERVER — that is what the stored `progress`
+      // field buys, and why nothing here recomputes it on the way past.
+      const page = await apiRef.current.listFocuses({ orderBy: 'progress', pageSize: 100 });
+      setFocuses(page.results);
+      return page.results;
+    } catch (err) {
+      setFocuses([]);
+      setError(failureMessage(err));
+      return [] as Focus[];
+    } finally {
+      setLoadingFocuses(false);
+    }
+  }, []);
+
+  React.useEffect(() => {
+    let live = true;
+    void (async () => {
+      const loaded = await loadFocuses();
+      if (!live || !apiRef.current.focusStanding) return;
+      // Bounded fan-out, and the clock is passed IN so "overdue" is computed
+      // against the frozen mount time rather than a fresh Date.now() per call.
+      const standing = apiRef.current.focusStanding.bind(apiRef.current);
+      for (let i = 0; i < loaded.length && live; i += STANDING_CONCURRENCY) {
+        const slice = loaded.slice(i, i + STANDING_CONCURRENCY);
+        const results = await Promise.all(
+          slice.map((focus) => standing(focus.id, clock).catch(() => null)),
+        );
+        if (!live) return;
+        setStandings((prev) => {
+          const next = { ...prev };
+          for (const result of results) if (result) next[result.focusId] = result;
+          return next;
+        });
+      }
+    })();
+    return () => { live = false; };
+    // `scope.orgId` and not `scope`: an app that rebuilds the scope object every
+    // render must not turn that into a refetch loop.
+  }, [loadFocuses, clock, scope.orgId, epoch]);
+
+  // -- items ---------------------------------------------------------------
+
+  const itemQuery = React.useMemo<CommitmentQuery>(() => ({
+    status: showDone ? 'done' : (['open', 'blocked'] as CommitmentStatus[]),
+    ...(owner.trim() ? { owner: owner.trim() } : {}),
+    ...(selected ? { focus: selected } : {}),
+    pageSize: 200,
+  }), [showDone, owner, selected]);
+
+  React.useEffect(() => {
+    let live = true;
+    setLoadingItems(true);
+    void apiRef.current
+      .listCommitments(itemQuery)
+      .then((page) => {
+        if (!live) return;
+        setItems(page.results);
+        setApplied(page.appliedFilters ?? []);
+      })
+      .catch((err) => { if (live) { setItems([]); setError(failureMessage(err)); } })
+      .finally(() => { if (live) setLoadingItems(false); });
+    return () => { live = false; };
+  }, [itemQuery, scope.orgId, epoch]);
+
+  React.useEffect(() => {
+    let live = true;
+    if (!api.listMembers) return undefined;
+    void apiRef.current.listMembers?.()
+      .then((roster) => { if (live) setMembers(roster); })
+      .catch(() => { /* the picker degrades to free text — see listMembers */ });
+    return () => { live = false; };
+  }, [api.listMembers, scope.orgId]);
+
+  /**
+   * Narrowed again in the browser, over what the server returned.
+   *
+   * NOT redundant with the server filter: a deployment whose API ignores
+   * `status` would otherwise render closed items under an "Outstanding" heading
+   * with only the banner to explain it. The banner says the narrowing happened;
+   * this is the narrowing.
+   */
+  const visible = React.useMemo(() => {
+    const wanted = showDone
+      ? (item: Commitment) => item.status === 'done' || item.status === 'dropped'
+      : (item: Commitment) => item.status === 'open' || item.status === 'blocked';
+    const byOwner = owner.trim().toLowerCase();
+    return items
+      .filter(wanted)
+      .filter((item) => !byOwner || (item.ownerName ?? '').toLowerCase().includes(byOwner))
+      .sort(compareForScreen(clock));
+  }, [items, showDone, owner, clock]);
+
+  const refresh = React.useCallback(() => setEpoch((n) => n + 1), []);
+  const selectedFocus = focuses.find((focus) => focus.id === selected) ?? null;
+  const overdueCount = visible.filter((item) => isOverdue(item, clock)).length;
+
+  return (
+    <div className={cn.root}>
+      <section className={cn.section}>
+        <div className="flex flex-wrap items-center gap-2">
+          <h2 className={cn.heading}>Focuses</h2>
+          {canAuthor ? (
+            <NewFocusForm
+              classNames={cn}
+              onCreate={async (draft) => {
+                await apiRef.current.createFocus!(draft);
+                refresh();
+              }}
+              onError={setError}
+            />
+          ) : null}
+        </div>
+
+        {error ? <p className={cn.error} role="alert">{error}</p> : null}
+
+        {loadingFocuses ? <p className={cn.muted}>Loading…</p> : null}
+
+        {!loadingFocuses && focuses.length === 0 ? (
+          <p className={cn.muted}>
+            {/* Advice, and only when it is true. A workspace with no focuses is
+                a workspace nobody has set one up in — distinct from a filtered
+                view that came back empty, which is the distinction the tracker
+                had to learn the hard way. */}
+            No focuses yet. A focus is something you are trying to achieve — a
+            launch, a quarter’s revenue, a client matter — and items get filed
+            under it.
+          </p>
+        ) : null}
+
+        <div className="grid gap-3 sm:grid-cols-2 lg:grid-cols-3">
+          {focuses.map((focus) => (
+            <FocusCard
+              key={focus.id}
+              focus={focus}
+              standing={standings[focus.id] ?? null}
+              selected={focus.id === selected}
+              classNames={cn}
+              onSelect={() => setSelected(focus.id === selected ? null : focus.id)}
+            />
+          ))}
+        </div>
+      </section>
+
+      <section className={cn.section} aria-label="Items">
+        <div className="flex flex-wrap items-center gap-2">
+          <h2 className={cn.heading}>
+            {loadingItems
+              ? 'Loading…'
+              : `${visible.length} item${visible.length === 1 ? '' : 's'}` +
+                (selectedFocus ? ` in ${selectedFocus.title}` : ' across every focus') +
+                (overdueCount ? ` · ${overdueCount} overdue` : '')}
+          </h2>
+
+          {selected ? (
+            <button type="button" className={cn.secondaryButton} onClick={() => setSelected(null)}>
+              Show everything
+            </button>
+          ) : null}
+
+          <label className="ml-auto flex items-center gap-2">
+            <span className="sr-only">Filter by owner</span>
+            <input
+              className={cn.input}
+              value={owner}
+              placeholder="Owner"
+              onChange={(event) => setOwner(event.target.value)}
+            />
+          </label>
+
+          <button
+            type="button"
+            className={showDone ? cn.button : cn.secondaryButton}
+            aria-pressed={showDone}
+            onClick={() => setShowDone((on) => !on)}
+          >
+            {showDone ? 'Showing closed' : 'Show closed'}
+          </button>
+        </div>
+
+        <UnfilteredNotice
+          requested={PLANNING_FILTER_KEYS}
+          applied={applied}
+          query={itemQuery}
+          className={cn.warning}
+        />
+
+        {canAuthor ? (
+          <NewItemForm
+            classNames={cn}
+            members={members}
+            focusId={selected}
+            focusTitle={selectedFocus?.title ?? null}
+            onCreate={async (draft) => {
+              await apiRef.current.createCommitment!(draft);
+              refresh();
+            }}
+            onError={setError}
+          />
+        ) : null}
+
+        {!loadingItems && visible.length === 0 ? (
+          <p className={cn.muted}>
+            {selectedFocus
+              ? 'Nothing is filed under this focus yet.'
+              : 'Nothing matches this view.'}
+          </p>
+        ) : null}
+
+        {visible.map((item) => (
+          <WorkItemRow
+            key={item.externalId}
+            item={item}
+            now={clock}
+            classNames={cn}
+            onOpenDocument={onOpenDocument}
+            actions={
+              api.fileCommitment && focuses.length ? (
+                <FileControl
+                  item={item}
+                  focuses={focuses}
+                  classNames={cn}
+                  onFile={async (focusId) => {
+                    await apiRef.current.fileCommitment!(item, focusId);
+                    refresh();
+                  }}
+                  onError={setError}
+                />
+              ) : null
+            }
+          />
+        ))}
+      </section>
+    </div>
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+function FocusCard({
+  focus, standing, selected, classNames: cn, onSelect,
+}: {
+  focus: Focus;
+  standing: FocusStanding | null;
+  selected: boolean;
+  classNames: Record<PlanningSlot, string>;
+  onSelect: () => void;
+}) {
+  const progress = displayProgress(focus, standing);
+
+  return (
+    <button
+      type="button"
+      onClick={onSelect}
+      aria-pressed={selected}
+      className={`${cn.card} text-left ${selected ? 'ring-2 ring-gray-900' : ''}`}
+    >
+      <div className="flex flex-wrap items-center gap-2">
+        <span className={cn.badge}>{focus.status.replace(/_/g, ' ')}</span>
+        {focus.category ? <span className={cn.badge}>{focus.category}</span> : null}
+        {focus.timeFrame ? (
+          <span className={cn.badge}>
+            {focus.timeFrame}{focus.year ? ` ${focus.year}` : ''}
+          </span>
+        ) : null}
+      </div>
+
+      <h3 className="mt-2 text-sm font-medium text-gray-900">{focus.title}</h3>
+      {focus.detail ? <p className={`mt-1 ${cn.muted}`}>{focus.detail}</p> : null}
+
+      {progress !== null ? (
+        <div className="mt-3">
+          <div className={cn.progressTrack}>
+            <div className={cn.progressBar} style={{ width: `${Math.round(progress * 100)}%` }} />
+          </div>
+        </div>
+      ) : null}
+
+      <p className={`mt-2 ${cn.muted}`}>
+        {standing === null ? (
+          // Not "0 of 0". A standing that has not arrived and a focus with
+          // nothing under it are different facts, and only one of them is
+          // actionable.
+          'Counting…'
+        ) : standing.total === 0 ? (
+          'Nothing filed under this yet'
+        ) : (
+          <>
+            {standing.done} of {standing.total} done
+            {standing.overdue ? ` · ${standing.overdue} overdue` : ''}
+          </>
+        )}
+        {focus.targetValue !== undefined && focus.targetValue !== null ? (
+          <> · {focus.currentValue ?? 0} / {focus.targetValue} {focus.unit ?? ''}</>
+        ) : null}
+      </p>
+      {focus.ownerName ? <p className={`mt-1 ${cn.muted}`}>{focus.ownerName}</p> : null}
+    </button>
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+function NewFocusForm({
+  classNames: cn, onCreate, onError,
+}: {
+  classNames: Record<PlanningSlot, string>;
+  onCreate: (draft: FocusDraft) => Promise<void>;
+  onError: (message: string) => void;
+}) {
+  const [open, setOpen] = React.useState(false);
+  const [title, setTitle] = React.useState('');
+  const [status, setStatus] = React.useState<FocusStatus>('active');
+  const [busy, setBusy] = React.useState(false);
+
+  if (!open) {
+    return (
+      <button type="button" className={`${cn.secondaryButton} ml-auto`} onClick={() => setOpen(true)}>
+        New focus
+      </button>
+    );
+  }
+
+  return (
+    <form
+      className="ml-auto flex flex-wrap items-center gap-2"
+      onSubmit={async (event) => {
+        event.preventDefault();
+        if (!title.trim()) return;
+        setBusy(true);
+        try {
+          await onCreate({ title: title.trim(), status });
+          setTitle('');
+          setOpen(false);
+        } catch (err) {
+          onError(failureMessage(err));
+        } finally {
+          setBusy(false);
+        }
+      }}
+    >
+      <label>
+        <span className="sr-only">Focus title</span>
+        <input
+          className={cn.input}
+          value={title}
+          placeholder="What are you trying to achieve?"
+          onChange={(event) => setTitle(event.target.value)}
+        />
+      </label>
+      <label>
+        <span className="sr-only">Status</span>
+        <select
+          className={cn.input}
+          value={status}
+          onChange={(event) => setStatus(event.target.value as FocusStatus)}
+        >
+          {FOCUS_STATUS_OPTIONS.map((option) => (
+            <option key={option} value={option}>{option.replace(/_/g, ' ')}</option>
+          ))}
+        </select>
+      </label>
+      <button type="submit" className={cn.button} disabled={busy || !title.trim()}>
+        {busy ? 'Adding…' : 'Add focus'}
+      </button>
+      <button type="button" className={cn.secondaryButton} onClick={() => setOpen(false)}>
+        Cancel
+      </button>
+    </form>
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+function NewItemForm({
+  classNames: cn, members, focusId, focusTitle, onCreate, onError,
+}: {
+  classNames: Record<PlanningSlot, string>;
+  members: Array<{ sub: string; email: string; name?: string }>;
+  focusId: string | null;
+  focusTitle: string | null;
+  onCreate: (draft: AuthoredItem) => Promise<void>;
+  onError: (message: string) => void;
+}) {
+  const [title, setTitle] = React.useState('');
+  const [subtype, setSubtype] = React.useState('action');
+  const [ownerSub, setOwnerSub] = React.useState('');
+  const [dueAt, setDueAt] = React.useState('');
+  const [priority, setPriority] = React.useState('');
+  const [busy, setBusy] = React.useState(false);
+
+  const member = members.find((entry) => entry.sub === ownerSub);
+
+  return (
+    <form
+      className={`${cn.card} flex flex-wrap items-end gap-2`}
+      onSubmit={async (event) => {
+        event.preventDefault();
+        if (!title.trim()) return;
+        setBusy(true);
+        try {
+          await onCreate({
+            title: title.trim(),
+            subtype,
+            ...(ownerSub ? { ownerSub } : {}),
+            // The NAME travels with the id, and this is the point of
+            // bd startsim-768w.38.29: the roster is the join, but the row must
+            // still read correctly on a screen that has no roster — and beside
+            // extracted rows whose owner was only ever a name in a transcript.
+            ...(member ? { ownerName: member.name || member.email } : {}),
+            ...(dueAt ? { dueAt: new Date(dueAt).toISOString() } : {}),
+            ...(priority !== '' ? { priority: Number(priority) } : {}),
+            ...(focusId ? { focusId } : {}),
+          });
+          setTitle('');
+          setDueAt('');
+          setPriority('');
+        } catch (err) {
+          onError(failureMessage(err));
+        } finally {
+          setBusy(false);
+        }
+      }}
+    >
+      <label className="flex-1">
+        <span className={cn.muted}>
+          {focusTitle ? `New item in ${focusTitle}` : 'New item (not filed under a focus)'}
+        </span>
+        <input
+          className={`${cn.input} mt-1 w-full`}
+          value={title}
+          placeholder="What needs doing?"
+          onChange={(event) => setTitle(event.target.value)}
+        />
+      </label>
+
+      <label>
+        <span className="sr-only">Kind</span>
+        <select
+          className={cn.input}
+          value={subtype}
+          onChange={(event) => setSubtype(event.target.value)}
+        >
+          {SUBTYPE_OPTIONS.map((option) => (
+            <option key={option} value={option}>{option}</option>
+          ))}
+        </select>
+      </label>
+
+      {members.length ? (
+        <label>
+          <span className="sr-only">Owner</span>
+          <select
+            className={cn.input}
+            value={ownerSub}
+            onChange={(event) => setOwnerSub(event.target.value)}
+          >
+            <option value="">Unassigned</option>
+            {members.map((entry) => (
+              <option key={entry.sub} value={entry.sub}>{entry.name || entry.email}</option>
+            ))}
+          </select>
+        </label>
+      ) : null}
+
+      <label>
+        <span className="sr-only">Due date</span>
+        <input
+          type="date"
+          className={cn.input}
+          value={dueAt}
+          onChange={(event) => setDueAt(event.target.value)}
+        />
+      </label>
+
+      <label>
+        <span className="sr-only">Priority</span>
+        <select
+          className={cn.input}
+          value={priority}
+          onChange={(event) => setPriority(event.target.value)}
+        >
+          {/* Blank is the default and it MEANS untriaged. Defaulting to Medium
+              would put every new row in the middle of a triage list as though
+              somebody had judged it. */}
+          <option value="">No priority</option>
+          {PRIORITY_OPTIONS.map((option) => (
+            <option key={option.value} value={option.value}>{option.label}</option>
+          ))}
+        </select>
+      </label>
+
+      <button type="submit" className={cn.button} disabled={busy || !title.trim()}>
+        {busy ? 'Adding…' : 'Add item'}
+      </button>
+    </form>
+  );
+}
+
+// ---------------------------------------------------------------------------
+
+function FileControl({
+  item, focuses, classNames: cn, onFile, onError,
+}: {
+  item: Commitment;
+  focuses: Focus[];
+  classNames: Record<PlanningSlot, string>;
+  onFile: (focusId: string | null) => Promise<void>;
+  onError: (message: string) => void;
+}) {
+  const [busy, setBusy] = React.useState(false);
+  return (
+    <label>
+      <span className="sr-only">File {item.title} under a focus</span>
+      <select
+        className={cn.input}
+        disabled={busy}
+        value={item.focusId ?? ''}
+        onChange={async (event) => {
+          const next = event.target.value || null;
+          setBusy(true);
+          try {
+            await onFile(next);
+          } catch (err) {
+            onError(failureMessage(err));
+          } finally {
+            setBusy(false);
+          }
+        }}
+      >
+        <option value="">Unfiled</option>
+        {focuses.map((focus) => (
+          <option key={focus.id} value={focus.id}>{focus.title}</option>
+        ))}
+      </select>
+    </label>
+  );
+}