gloomberb 0.16.0 → 0.16.2

package/src/plugins/builtin/world-venue-map/basemap.ts

@@ -0,0 +1,214 @@
+/**
+ * Land and borders under the desktop and web map: Natural Earth 1:50m for the
+ * whole world, and 1:10m tiles for the part in view once the map is zoomed in.
+ * Both are lazy chunks (see `natural-earth/`), so the app bundle carries
+ * neither. Only the desktop and web builds say where they are; the terminal,
+ * which draws its own outline, has nothing to load and bundles none of it.
+ *
+ * Paths are in degrees, x east and y south (minus the latitude), so the map
+ * places every path with one transform and pan or zoom rebuilds nothing.
+ */
+
+/** What a generated chunk exports: coordinates as integers of `STEP` degrees, polyline-encoded. */
+export interface BasemapChunk {
+  STEP: number;
+  LAND: string;
+  BORDERS: string;
+}
+
+/** West, south, east, north in degrees. */
+export type GeoBox = readonly [number, number, number, number];
+
+export interface DetailTile {
+  id: string;
+  /** What the tile was cut to: its square, a hair wider so neighbours overlap. */
+  box: GeoBox;
+  load: () => Promise<BasemapChunk>;
+}
+
+export interface BasemapPaths {
+  /** Land rings, filled even-odd so lakes stay open. */
+  land: string;
+  /** The same rings without the edges a tile, the date line or the map's southern edge cut. */
+  coast: string;
+  borders: string;
+}
+
+/** The map stops at 60°S; the 1:50m chunk is cut there. */
+const WORLD_BOX: GeoBox = [-180, -60, 180, 90];
+
+/**
+ * Pixels per degree where 1:10m takes over: a view about 30 degrees wide on
+ * a laptop. 1:50m keeps about a fiftieth of a degree, so closer in its
+ * coastlines turn into straight runs; further out 1:10m only costs paint.
+ */
+export const DETAIL_MIN_PX_PER_DEGREE = 32;
+/** Below this the world is far enough out for a faint graticule to help. */
+export const GRATICULE_MAX_PX_PER_DEGREE = 4.5;
+/** Tiles decoded and kept; a long session over many seas drops the oldest. */
+export const TILE_CACHE_SIZE = 40;
+
+export type BasemapLevel = "world" | "detail";
+
+export function basemapLevel(pxPerDegree: number): BasemapLevel {
+  return pxPerDegree >= DETAIL_MIN_PX_PER_DEGREE ? "detail" : "world";
+}
+
+/** Decodes a chunk's rings or lines into flat integer runs: x0, y0, x1, y1... */
+export function decodeParts(text: string): Int32Array[] {
+  if (!text) return [];
+  return text.split(" ").map((part) => {
+    const values: number[] = [];
+    let index = 0;
+    let lon = 0;
+    let lat = 0;
+    let axis = 0;
+    while (index < part.length) {
+      let shift = 0;
+      let bits = 0;
+      let byte = 0;
+      do {
+        byte = part.charCodeAt(index++) - 63;
+        bits |= (byte & 0x1f) << shift;
+        shift += 5;
+      } while (byte >= 0x20 && index < part.length);
+      const delta = bits & 1 ? ~(bits >> 1) : bits >> 1;
+      if (axis === 0) {
+        lon += delta;
+        values.push(lon);
+      } else {
+        lat += delta;
+        values.push(lat);
+      }
+      axis ^= 1;
+    }
+    return Int32Array.from(values);
+  });
+}
+
+function onCutEdge(x1: number, y1: number, x2: number, y2: number, box: readonly number[]): boolean {
+  return (x1 === x2 && (x1 === box[0] || x1 === box[2])) || (y1 === y2 && (y1 === box[1] || y1 === box[3]));
+}
+
+/** Builds the land, coast and border paths of one chunk cut to `box`. */
+export function basemapPaths(chunk: BasemapChunk, box: GeoBox): BasemapPaths {
+  const scale = Math.round(1 / chunk.STEP);
+  const cut = box.map((value) => Math.round(value * scale));
+  const x = (value: number) => value / scale;
+  const y = (value: number) => -value / scale;
+  let land = "";
+  let coast = "";
+  for (const ring of decodeParts(chunk.LAND)) {
+    const count = ring.length / 2;
+    if (count < 3) continue;
+    land += `M${x(ring[0]!)} ${y(ring[1]!)}`;
+    for (let index = 1; index < count; index += 1) land += `L${x(ring[index * 2]!)} ${y(ring[index * 2 + 1]!)}`;
+    land += "Z";
+    let drawing = false;
+    for (let index = 0; index < count; index += 1) {
+      const next = (index + 1) % count;
+      const x1 = ring[index * 2]!;
+      const y1 = ring[index * 2 + 1]!;
+      const x2 = ring[next * 2]!;
+      const y2 = ring[next * 2 + 1]!;
+      if (onCutEdge(x1, y1, x2, y2, cut)) {
+        drawing = false;
+        continue;
+      }
+      if (!drawing) coast += `M${x(x1)} ${y(y1)}`;
+      coast += `L${x(x2)} ${y(y2)}`;
+      drawing = true;
+    }
+  }
+  let borders = "";
+  for (const line of decodeParts(chunk.BORDERS)) {
+    for (let index = 0; index < line.length; index += 2) borders += `${index ? "L" : "M"}${x(line[index]!)} ${y(line[index + 1]!)}`;
+  }
+  return { land, coast, borders };
+}
+
+/** Tiles under the view, with a margin either side so a pan finds its tiles loaded. */
+export function tilesInView(tiles: readonly DetailTile[], view: GeoBox, margin = 0.15): DetailTile[] {
+  const padX = (view[2] - view[0]) * margin;
+  const padY = (view[3] - view[1]) * margin;
+  const west = view[0] - padX;
+  const south = view[1] - padY;
+  const east = view[2] + padX;
+  const north = view[3] + padY;
+  return tiles.filter(({ box }) => box[0] < east && box[2] > west && box[1] < north && box[3] > south);
+}
+
+/** What `natural-earth/index.chunk.ts` exports. */
+interface BasemapIndex {
+  loadWorld: () => Promise<BasemapChunk>;
+  DETAIL_TILES: readonly DetailTile[];
+}
+
+/**
+ * `./natural-earth/index.chunk.js` in the desktop and web builds, which ship
+ * the chunks beside the app; absent everywhere else. Written as the import's
+ * own specifier so a build without it has no path to follow into the data.
+ */
+declare const __GLOOM_WORLD_MAP_DATA__: string | undefined;
+
+let indexModule: Promise<BasemapIndex> | null = null;
+let worldPaths: Promise<BasemapPaths> | null = null;
+const tilePaths = new Map<string, Promise<BasemapPaths>>();
+
+function loadIndex(): Promise<BasemapIndex> {
+  if (typeof __GLOOM_WORLD_MAP_DATA__ !== "string") return Promise.reject(new Error("No map data in this build"));
+  indexModule ??= (import(__GLOOM_WORLD_MAP_DATA__) as Promise<BasemapIndex>).catch((error: unknown) => {
+    indexModule = null;
+    throw error;
+  });
+  return indexModule;
+}
+
+export function loadWorldBasemap(): Promise<BasemapPaths> {
+  worldPaths ??= loadIndex()
+    .then((index) => index.loadWorld())
+    .then((chunk) => basemapPaths(chunk, WORLD_BOX))
+    .catch((error: unknown) => {
+      worldPaths = null;
+      throw error;
+    });
+  return worldPaths;
+}
+
+export function loadDetailIndex(): Promise<readonly DetailTile[]> {
+  return loadIndex().then((index) => index.DETAIL_TILES);
+}
+
+/**
+ * Decoding a tile takes a few milliseconds; a view that needs twenty would
+ * hold a frame for a quarter of a second. They take turns, one per task.
+ */
+let decodeQueue: Promise<unknown> = Promise.resolve();
+
+function nextTask(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+export function loadDetailTile(tile: DetailTile): Promise<BasemapPaths> {
+  const cached = tilePaths.get(tile.id);
+  if (cached) {
+    // Most recently used last, so the oldest is the first to go.
+    tilePaths.delete(tile.id);
+    tilePaths.set(tile.id, cached);
+    return cached;
+  }
+  const pending = tile.load()
+    .then((chunk) => {
+      const decoded = decodeQueue.then(nextTask).then(() => basemapPaths(chunk, tile.box));
+      decodeQueue = decoded.catch(() => {});
+      return decoded;
+    })
+    .catch((error: unknown) => {
+      tilePaths.delete(tile.id);
+      throw error;
+    });
+  tilePaths.set(tile.id, pending);
+  while (tilePaths.size > TILE_CACHE_SIZE) tilePaths.delete(tilePaths.keys().next().value!);
+  return pending;
+}
+

package/src/plugins/builtin/world-venue-map/client.ts

@@ -0,0 +1,45 @@
+/** Map data through the Cloud client: venues, the geo layer catalog, entity pages and details. */
+import { apiClient, type CloudWorldVenueMapPayload } from "../../../api-client";
+import {
+  getGeoEntities,
+  getGeoEntity,
+  loadGeoCatalog,
+  type GeoEntitiesPayload,
+  type GeoEntitiesQuery,
+  type GeoEntityPayload,
+  type GeoLayersPayload,
+  type GeoRequest,
+} from "../../../api-client/geo";
+
+export const ENTITY_PAGE_SIZE = 100;
+
+/** Requests under /cloud/geo/ through the shared client, resolved late so tests can stub it. */
+export const cloudGeoRequest: GeoRequest = (path, init) => apiClient.geo(path, init);
+
+export async function loadWorldVenues(): Promise<CloudWorldVenueMapPayload> {
+  const response = await apiClient.getCloudWorldVenues();
+  if (!response.data) throw new Error(response.reasonCode ?? "World venue data unavailable");
+  return response.stale ? { ...response.data, stale: true } : response.data;
+}
+
+export function loadMapCatalog(request: GeoRequest = cloudGeoRequest, force = false): Promise<GeoLayersPayload | null> {
+  return loadGeoCatalog(request, { force });
+}
+
+export function loadEntityPage(
+  layerId: string,
+  query: GeoEntitiesQuery,
+  signal: AbortSignal,
+  request: GeoRequest = cloudGeoRequest,
+): Promise<GeoEntitiesPayload> {
+  return getGeoEntities(request, layerId, { limit: ENTITY_PAGE_SIZE, ...query }, signal);
+}
+
+export function loadEntityDetail(
+  layerId: string,
+  entityId: string,
+  signal?: AbortSignal,
+  request: GeoRequest = cloudGeoRequest,
+): Promise<GeoEntityPayload> {
+  return getGeoEntity(request, layerId, entityId, signal);
+}

package/src/plugins/builtin/world-venue-map/entity-detail.tsx

@@ -0,0 +1,147 @@
+import type { RefObject } from "react";
+import type {
+  GeoColumnFormat,
+  GeoEntityPayload,
+  GeoEntityRow,
+  GeoLayerInfo,
+  GeoPropValue,
+  GeoSeriesInfo,
+  GeoTickerLink,
+} from "../../../api-client/geo";
+import { ActionRow, DetailScrollBody, KeyValueRow, Section, StatGrid, type StatItem } from "../../../components";
+import { useThemeColors } from "../../../theme/theme-context";
+import { Box, Text, type ScrollBoxRenderable } from "../../../ui";
+import { clipToDisplayWidth, displayWidth } from "../../../utils/format";
+import { formatGeoValue, isChangeColumn, tickerLinkKey } from "./layers";
+
+interface EntityDetailProps {
+  layer: GeoLayerInfo;
+  row: GeoEntityRow | null;
+  detail: GeoEntityPayload | null;
+  /** The entity's series, main one first. */
+  series: readonly GeoSeriesInfo[];
+  width: number;
+  now: number;
+  scrollRef: RefObject<ScrollBoxRenderable | null>;
+  onOpenTicker: (link: GeoTickerLink) => void;
+  onOpenSeries: (series: GeoSeriesInfo) => void;
+}
+
+const SHORT_KEYS = new Set(["mmsi", "imo", "iata", "icao", "id"]);
+
+/** A number stored as a code (`shipType`, `navStatus`) means nothing on its own, so the detail leaves it out. */
+function isNumericCode(key: string, value: GeoPropValue): boolean {
+  return typeof value === "number" && /(Type|Status|Code)$/.test(key);
+}
+
+/** The unit a key carries that no column format draws: metres and degrees. */
+function detailText(key: string, value: GeoPropValue, now: number): string {
+  if (typeof value === "number" && /Deg$/.test(key)) return `${Math.round(value)}°`;
+  if (typeof value === "number" && /[a-z]M$/.test(key)) return `${formatGeoValue(value, Number.isInteger(value) ? "int" : "decimal1", now)} m`;
+  return formatGeoValue(value, detailFormat(key, value), now);
+}
+
+/** Detail fields carry no column format; the server puts units in the key (`lastSeen`, `importSharePct`). */
+function detailFormat(key: string, value: GeoPropValue): GeoColumnFormat | undefined {
+  if (SHORT_KEYS.has(key.toLowerCase())) return "text";
+  if (typeof value === "string" && /(At|Seen|Time)$/.test(key)) return "datetime";
+  if (typeof value !== "number") return undefined;
+  if (/Pct$/.test(key)) return "percent1";
+  if (/Km$/.test(key)) return "km";
+  if (/Kn$/.test(key)) return "knots";
+  return Number.isInteger(value) ? "int" : "decimal1";
+}
+
+/** `lastSeen` reads "Last seen", `mmsi` reads "MMSI". */
+function humanizeKey(key: string): string {
+  if (SHORT_KEYS.has(key.toLowerCase())) return key.toUpperCase();
+  // The unit suffix moves into the value: "importSharePct" reads "Import share", "lengthM" "Length".
+  const words = key.replace(/(Pct|Km|Kn|Deg|M)$/, "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([a-z])(\d)/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .trim()
+    .toLowerCase()
+    .replace(/\b(\d+)d\b/g, "$1D");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+function trailSpan(trail: GeoEntityPayload["trail"]): string | null {
+  if (!trail || trail.length < 2) return null;
+  const start = Date.parse(trail[0]![2]);
+  const end = Date.parse(trail.at(-1)![2]);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return null;
+  const minutes = Math.round((end - start) / 60_000);
+  return minutes < 90 ? `Last ${minutes}m` : `Last ${Math.round(minutes / 60)}h`;
+}
+
+const VIA_WORDS: Record<GeoTickerLink["via"], string> = {
+  owner: "Owner",
+  operator: "Operator",
+  route: "Route",
+  sector: "Sector",
+};
+
+/** One row, one line: a label and what it is, clipped so a long note never wraps over the next row. */
+function LinkRow({ label, detail, width, onPress }: { label: string; detail: string; width: number; onPress: () => void }) {
+  const colors = useThemeColors();
+  const room = Math.max(0, width - displayWidth(label) - 3);
+  return (
+    <ActionRow label={label} onPress={onPress} width={width}>
+      {room > 3 ? <Text fg={colors.textDim}>{clipToDisplayWidth(detail, room)}</Text> : null}
+    </ActionRow>
+  );
+}
+
+/** One entity: its figures, the companies it links to, its series and the rest of its fields. */
+export function EntityDetail({ layer, row, detail, series, width, now, scrollRef, onOpenTicker, onOpenSeries }: EntityDetailProps) {
+  const props: Record<string, GeoPropValue> = { ...row?.props, ...detail?.feature.props, ...detail?.detail };
+  const columns = layer.columns.filter((column) => column.key !== "label");
+  const shown = new Set(["label", ...columns.map((column) => column.key)]);
+  const figures: StatItem[] = columns.flatMap((column) => {
+    const value = formatGeoValue(props[column.key], column.format, now, isChangeColumn(column));
+    return value ? [{ id: column.key, label: column.label, value }] : [];
+  });
+  const tickers = detail?.feature.tickers ?? row?.tickers ?? [];
+  const track = trailSpan(detail?.trail);
+  const title = row?.label ?? detail?.feature.label;
+  // The stack header already names the entity, so a `name` field that repeats it is left out.
+  const rest = Object.entries(props).filter(([key, value]) => !shown.has(key) && value !== null && value !== "" && value !== title && !isNumericCode(key, value));
+  const innerWidth = Math.max(10, width - 2);
+  const labelWidth = Math.min(16, Math.max(8, ...rest.map(([key]) => displayWidth(humanizeKey(key)) + 1), track ? 6 : 0));
+  return (
+    <DetailScrollBody ref={scrollRef} resetScrollKey={`${layer.id}:${row?.id ?? detail?.feature.id ?? ""}`}>
+      {figures.length ? <StatGrid items={figures} width={innerWidth} /> : null}
+      {tickers.length ? (
+        <Section title="Linked Tickers" width={innerWidth}>
+          {tickers.map((link) => (
+            <LinkRow
+              key={`${tickerLinkKey(link)}:${link.via}`}
+              label={link.symbol}
+              detail={[VIA_WORDS[link.via] ?? link.via, link.confidence === "inferred" ? "inferred" : null, link.note ?? null].filter(Boolean).join(" · ")}
+              width={innerWidth}
+              onPress={() => onOpenTicker(link)}
+            />
+          ))}
+        </Section>
+      ) : null}
+      {series.length ? (
+        <Section title="Series" width={innerWidth}>
+          {series.map((entry) => (
+            <LinkRow key={entry.id} label={entry.name} detail={entry.frequency} width={innerWidth} onPress={() => onOpenSeries(entry)} />
+          ))}
+        </Section>
+      ) : null}
+      {track || rest.length ? (
+        <Section title="Details" width={innerWidth}>
+          <Box flexDirection="column">
+            {track ? <KeyValueRow label="Track" value={track} width={innerWidth} labelWidth={labelWidth} /> : null}
+            {rest.map(([key, value]) => (
+              <KeyValueRow key={key} label={humanizeKey(key)} value={detailText(key, value, now)} width={innerWidth} labelWidth={labelWidth} />
+            ))}
+          </Box>
+        </Section>
+      ) : null}
+    </DetailScrollBody>
+  );
+}

package/src/plugins/builtin/world-venue-map/entity-table.ts

@@ -0,0 +1,59 @@
+/** The entity table: the layer's own columns fitted to the width, plus the linked ticker. */
+import type { GeoColumn, GeoColumnFormat, GeoEntityRow } from "../../../api-client/geo";
+import type { DataTableColumn } from "../../../components";
+import { getTableWidth } from "../../../components/ui/table-layout";
+import { columnValue, formatGeoValue, isChangeColumn, plainGeoValue } from "./layers";
+
+export const TICKER_COLUMN_ID = "__ticker";
+
+export type EntityColumn = DataTableColumn & {
+  geo: GeoColumn | null;
+};
+
+const FORMAT_WIDTH: Record<GeoColumnFormat, number> = {
+  text: 10,
+  int: 6,
+  decimal1: 6,
+  percent1: 6,
+  datetime: 7,
+  knots: 7,
+  km: 8,
+};
+
+const TICKER_WIDTH = 6;
+const MIN_LABEL_WIDTH = 14;
+
+/** A right-aligned text column is a code (an MMSI, an IMO number): kept only when there is room left. */
+function isIdentifier(column: GeoColumn): boolean {
+  return column.align === "right" && (column.format ?? "text") === "text";
+}
+
+/**
+ * The label first and the ticker last, then the layer's columns in its order
+ * while they fit, codes after everything else; a narrow pane keeps the label
+ * and the ticker.
+ */
+export function entityColumns(columns: readonly GeoColumn[], width: number): EntityColumn[] {
+  const [first, ...rest] = columns.length ? columns : [{ key: "label", label: "Name" } satisfies GeoColumn];
+  const label: EntityColumn = { id: first!.key, label: first!.label, width: MIN_LABEL_WIDTH, flexGrow: 1, align: "left", geo: first! };
+  const ticker: EntityColumn = { id: TICKER_COLUMN_ID, label: "Ticker", width: TICKER_WIDTH, align: "left", geo: null };
+  const fits = (candidate: EntityColumn[]) => getTableWidth(candidate) <= width;
+  const tail = fits([label, ticker]) ? [ticker] : [];
+  const picked = new Set<GeoColumn>();
+  const inOrder = () => rest.filter((column) => picked.has(column)).map((column): EntityColumn => ({
+    id: column.key, label: column.label, width: FORMAT_WIDTH[column.format ?? "text"], align: column.align ?? "left", geo: column,
+  }));
+  for (const column of [...rest.filter((entry) => !isIdentifier(entry)), ...rest.filter(isIdentifier)]) {
+    picked.add(column);
+    if (!fits([label, ...inOrder(), ...tail])) picked.delete(column);
+  }
+  const middle = inOrder();
+  const spare = Math.max(0, width - getTableWidth([label, ...middle, ...tail]));
+  return [{ ...label, width: MIN_LABEL_WIDTH + spare }, ...middle, ...tail];
+}
+
+/** A cell's text and the plain value an export writes. */
+export function entityCellText(row: GeoEntityRow, column: GeoColumn, now: number): { text: string; value: number | string | null } {
+  const raw = columnValue(row, column);
+  return { text: formatGeoValue(raw, column.format, now, isChangeColumn(column)), value: plainGeoValue(raw) };
+}

package/src/plugins/builtin/world-venue-map/evidence.ts

@@ -0,0 +1,77 @@
+/**
+ * What `gloomberb shot MAP <layers>` certifies: the layers the map drew and
+ * what each held, so a capture taken before the features arrived is refused.
+ */
+import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";
+import { useRemoteUiNode } from "../../../remote/semantic-tree";
+import { isRecord } from "../../../utils/guards";
+import type { GeoLayerState } from "./feed";
+import { WORLD_VENUE_MAP_PANE_ID } from "./ids";
+import { parseLayerTokens } from "./layers";
+
+interface WorldMapEvidenceLayer {
+  id: string;
+  phase: GeoLayerState["phase"];
+  features: number;
+  clusters: number;
+}
+
+interface WorldMapEvidence {
+  kind: "world-map";
+  version: 1;
+  complete: boolean;
+  plottedValueCount: number;
+  tokens: string[];
+  layers: WorldMapEvidenceLayer[];
+  tableRows: number;
+}
+
+const SETTLED = new Set<GeoLayerState["phase"]>(["ready", "unavailable", "zoom", "locked", "error"]);
+
+export function useWorldMapEvidence(tokens: readonly string[], states: readonly GeoLayerState[], tableRows: number, tableLoading: boolean) {
+  useRemoteUiNode({
+    role: "chart-data",
+    label: "Rendered world map layers",
+    getMetadata: () => {
+      const layers = states.map((state) => ({ id: state.layer.id, phase: state.phase, features: state.features.length, clusters: state.clusters.length }));
+      const complete = !tableLoading && states.every((state) => SETTLED.has(state.phase) && !state.loading);
+      return {
+        kind: "world-map",
+        version: 1,
+        complete,
+        ready: complete,
+        plottedValueCount: layers.reduce((sum, layer) => sum + layer.features + layer.clusters, 0) + tableRows,
+        tokens: [...tokens],
+        layers,
+        tableRows,
+      } satisfies WorldMapEvidence & { ready: boolean };
+    },
+  });
+}
+
+function requestedTokens(request: Parameters<PaneScreenshotEvidenceHook["mismatches"]>[1]): string[] {
+  const fromOption = parseLayerTokens(request.resolved.options.layer);
+  return fromOption.length ? fromOption : parseLayerTokens(request.resolved.createOptions?.arg ?? "");
+}
+
+export const worldMapScreenshotEvidence: PaneScreenshotEvidenceHook<WorldMapEvidence> = {
+  paneId: WORLD_VENUE_MAP_PANE_ID,
+  kind: "world-map",
+  label: "world map layers",
+  read(value) {
+    if (!isRecord(value) || value.kind !== "world-map" || value.version !== 1 || typeof value.complete !== "boolean"
+      || !Number.isSafeInteger(value.plottedValueCount) || !Array.isArray(value.layers) || !Array.isArray(value.tokens)) return null;
+    return value as unknown as WorldMapEvidence;
+  },
+  mismatches(evidence, request) {
+    const asked = requestedTokens(request);
+    return asked.join(",") === evidence.tokens.join(",") ? [] : ["Map layers differ from the request"];
+  },
+  unavailable(evidence) {
+    if (!evidence) return ["world map layers"];
+    return evidence.layers.filter((layer) => layer.phase === "error").map((layer) => layer.id);
+  },
+  symbols() {
+    return [];
+  },
+};