@svgrid/enterprise 2.5.2 → 2.6.0

package/src/alerts/alert-engine.ts

@@ -1,260 +0,0 @@
-/**
- * The pure alert engine - no DOM, no timers. It turns rules + data snapshots
- * into `AlertEvent`s, with true-edge de-duplication so a `dataChange` rule fires
- * once when a row starts matching (not on every re-evaluation while it keeps
- * matching). The reactive/observing wrapper lives in `alert-engine-attach.ts`.
- */
-import { evaluateChange, evaluatePredicate } from '../expressions/evaluate'
-import { collectColumnRefs } from '../expressions/parse'
-import type { EvalContext } from '../expressions/expression-types'
-import type { AlertEvent, AlertRule } from './alert-types'
-
-export type AlertEngineOptions<TData> = {
-  rules: AlertRule[]
-  getRowId: (row: TData) => string
-  /** Resolve a column id to a value (defaults to `row[id]`). */
-  getValue?: (row: TData, columnId: string) => unknown
-  locale?: string | ReadonlyArray<string>
-  /** Clock for `firedAt` (injectable for deterministic tests). */
-  now?: () => number
-}
-
-export type ValidateEditResult = {
-  vetoed: boolean
-  events: AlertEvent[]
-}
-
-export type AlertEngine<TData> = {
-  setRules(rules: AlertRule[]): void
-  getRules(): AlertRule[]
-  /** Full-snapshot pass: fires `dataChange`/`scheduled`/aggregate edges. */
-  evaluate(rows: ReadonlyArray<TData>): AlertEvent[]
-  /** Prev -> next pass: fires `relativeChange` plus `dataChange` edges. */
-  evaluateTransition(prev: ReadonlyArray<TData>, next: ReadonlyArray<TData>): AlertEvent[]
-  /** Would editing `(row, columnId) -> nextValue` trip a validation rule? */
-  validateEdit(row: TData, columnId: string, nextValue: unknown): ValidateEditResult
-  /**
-   * True iff some enabled rule reads a row's PREVIOUS value (a `relativeChange`
-   * trigger). When false, the observer can skip cloning prev-snapshots entirely
-   * - the hot-path saver for `dataChange`/aggregate-only rule sets over big feeds.
-   */
-  needsPrev(): boolean
-  /** True iff some enabled rule is aggregate-scope (needs the full row set). */
-  needsFullSet(): boolean
-  /** Forget edge memory so matching rows can fire again. */
-  reset(): void
-}
-
-const AGG_ROW_KEY = '*'
-
-/** Fill message-template tokens from the firing context. */
-export function renderTemplate(
-  template: string,
-  ctx: { rule: AlertRule; row?: Record<string, unknown>; columnId?: string; value?: unknown },
-): string {
-  const { rule, row, columnId, value } = ctx
-  return template
-    .replace(/\{rule\}/g, rule.name)
-    .replace(/\{severity\}/g, rule.severity)
-    .replace(/\{column\}/g, columnId ?? '')
-    .replace(/\{value\}/g, value == null ? '' : String(value))
-    .replace(/\{row\.([\w$]+)\}/g, (_m, key: string) => fmt(row?.[key]))
-    .replace(/\{([\w$]+)\}/g, (m, key: string) => (row && key in row ? fmt(row[key]) : m))
-}
-
-function fmt(v: unknown): string {
-  return v == null ? '' : String(v)
-}
-
-function defaultMessage(rule: AlertRule): string {
-  return rule.name
-}
-
-export function createAlertEngine<TData = Record<string, unknown>>(
-  options: AlertEngineOptions<TData>,
-): AlertEngine<TData> {
-  let rules = options.rules
-  const getValue = options.getValue
-  const now = options.now ?? (() => Date.now())
-  // Edge memory: keys currently satisfying a `dataChange`/aggregate predicate.
-  const active = new Set<string>()
-
-  const ctxFor = (row: TData, rows?: ReadonlyArray<TData>, prev?: TData): EvalContext<TData> => ({
-    row,
-    prev,
-    rows,
-    getValue,
-    locale: options.locale,
-  })
-
-  const val = (row: TData, columnId?: string): unknown =>
-    columnId == null
-      ? undefined
-      : getValue
-        ? getValue(row, columnId)
-        : (row as Record<string, unknown>)?.[columnId]
-
-  // A representative column for the message `{value}`/`{column}` tokens: the
-  // rule's explicit target, else the first column its predicate references.
-  const primaryColumn = (rule: AlertRule): string | undefined =>
-    rule.columns?.[0] ?? collectColumnRefs(rule.predicate)[0]
-
-  function buildEvent(
-    rule: AlertRule,
-    opts: { row?: TData; rowId?: string; columnId?: string; value?: unknown },
-  ): AlertEvent {
-    const msgAction = rule.actions.find((a) => a.message)
-    const template = msgAction?.message ?? defaultMessage(rule)
-    const message = renderTemplate(template, {
-      rule,
-      row: opts.row as Record<string, unknown> | undefined,
-      columnId: opts.columnId,
-      value: opts.value,
-    })
-    return {
-      ruleId: rule.id,
-      ruleName: rule.name,
-      severity: rule.severity,
-      scope: rule.scope,
-      triggerType: rule.trigger.type,
-      rowId: opts.rowId,
-      columnId: opts.columnId,
-      value: opts.value,
-      message,
-      actions: rule.actions,
-      firedAt: now(),
-    }
-  }
-
-  /** Aggregate-scope: one edge event when the predicate over all rows flips true. */
-  function evaluateAggregate(rule: AlertRule, rows: ReadonlyArray<TData>): AlertEvent[] {
-    const key = `${rule.id}::${AGG_ROW_KEY}`
-    const first = rows[0]
-    const matches = first != null && evaluatePredicate(rule.predicate, ctxFor(first, rows))
-    if (matches && !active.has(key)) {
-      active.add(key)
-      return [buildEvent(rule, {})]
-    }
-    if (!matches) active.delete(key)
-    return []
-  }
-
-  /** Row/cell dataChange: edge event when a row newly satisfies the predicate. */
-  function evaluateDataChangeRow(
-    rule: AlertRule,
-    row: TData,
-    rows: ReadonlyArray<TData>,
-  ): AlertEvent[] {
-    const id = options.getRowId(row)
-    const key = `${rule.id}::${id}`
-    const matches = evaluatePredicate(rule.predicate, ctxFor(row, rows))
-    if (matches && !active.has(key)) {
-      active.add(key)
-      const source = primaryColumn(rule)
-      // Expose the column on the event only for cell scope; still surface its
-      // value for the message tokens regardless of scope.
-      const columnId = rule.scope === 'cell' ? source : undefined
-      return [buildEvent(rule, { row, rowId: id, columnId, value: val(row, source) })]
-    }
-    if (!matches) active.delete(key)
-    return []
-  }
-
-  /** relativeChange: fires whenever the change test holds for a prev->next row. */
-  function evaluateRelative(
-    rule: AlertRule,
-    row: TData,
-    prev: TData | undefined,
-    rows: ReadonlyArray<TData>,
-  ): AlertEvent[] {
-    if (rule.trigger.type !== 'relativeChange' || prev == null) return []
-    const changed = evaluateChange(rule.trigger.expr, ctxFor(row, rows, prev))
-    if (!changed) return []
-    // Gate on the predicate too, so "price jumped AND price > 100" is expressible.
-    if (!evaluatePredicate(rule.predicate, ctxFor(row, rows, prev))) return []
-    const columnId = rule.trigger.expr.column
-    return [
-      buildEvent(rule, {
-        row,
-        rowId: options.getRowId(row),
-        columnId,
-        value: val(row, columnId),
-      }),
-    ]
-  }
-
-  function activeRules(): AlertRule[] {
-    return rules.filter((r) => r.enabled)
-  }
-
-  return {
-    setRules(next) {
-      rules = next
-    },
-    getRules() {
-      return rules
-    },
-    needsPrev() {
-      return rules.some((r) => r.enabled && r.trigger.type === 'relativeChange')
-    },
-    needsFullSet() {
-      return rules.some((r) => r.enabled && r.scope === 'aggregate')
-    },
-    reset() {
-      active.clear()
-    },
-
-    evaluate(rows) {
-      const events: AlertEvent[] = []
-      for (const rule of activeRules()) {
-        if (rule.scope === 'aggregate') {
-          events.push(...evaluateAggregate(rule, rows))
-        } else if (rule.trigger.type === 'dataChange' || rule.trigger.type === 'scheduled') {
-          for (const row of rows) events.push(...evaluateDataChangeRow(rule, row, rows))
-        }
-      }
-      return events
-    },
-
-    evaluateTransition(prev, next) {
-      const prevById = new Map<string, TData>()
-      for (const row of prev) prevById.set(options.getRowId(row), row)
-      const events: AlertEvent[] = []
-      for (const rule of activeRules()) {
-        if (rule.scope === 'aggregate') {
-          events.push(...evaluateAggregate(rule, next))
-          continue
-        }
-        for (const row of next) {
-          const before = prevById.get(options.getRowId(row))
-          if (rule.trigger.type === 'relativeChange') {
-            events.push(...evaluateRelative(rule, row, before, next))
-          } else if (rule.trigger.type === 'dataChange') {
-            events.push(...evaluateDataChangeRow(rule, row, next))
-          }
-        }
-      }
-      return events
-    },
-
-    validateEdit(row, columnId, nextValue) {
-      const candidate = { ...(row as Record<string, unknown>), [columnId]: nextValue } as TData
-      const events: AlertEvent[] = []
-      let vetoed = false
-      for (const rule of activeRules()) {
-        if (rule.trigger.type !== 'validation') continue
-        if (!evaluatePredicate(rule.predicate, ctxFor(candidate))) continue
-        events.push(
-          buildEvent(rule, {
-            row: candidate,
-            rowId: options.getRowId(candidate),
-            columnId,
-            value: nextValue,
-          }),
-        )
-        if (rule.actions.some((a) => a.kind === 'preventEdit')) vetoed = true
-      }
-      return { vetoed, events }
-    },
-  }
-}

package/src/alerts/alert-formats.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { rulesToConditionalFormats, toConditionalFormats } from './alert-formats'
-import type { AlertEvent, AlertRule } from './alert-types'
-
-type Row = { id: string; price: number }
-const getRowId = (r: Row) => r.id
-
-const event = (over: Partial<AlertEvent> = {}): AlertEvent => ({
-  ruleId: 'r1',
-  ruleName: 'High',
-  severity: 'warning',
-  scope: 'row',
-  triggerType: 'dataChange',
-  rowId: 'a',
-  message: 'hi',
-  actions: [{ kind: 'highlight', style: { background: '#fee2e2', color: '#991b1b' } }],
-  firedAt: 0,
-  ...over,
-})
-
-describe('toConditionalFormats', () => {
-  it('turns a highlight action into a row-matching RuleFormat', () => {
-    const formats = toConditionalFormats([event()], getRowId)
-    expect(formats).toHaveLength(1)
-    const f = formats[0]!
-    expect(f.type).toBe('rule')
-    if (f.type === 'rule') {
-      expect(f.background).toBe('#fee2e2')
-      expect(f.color).toBe('#991b1b')
-      expect(f.when({ value: 120, row: { id: 'a', price: 120 } })).toBe(true)
-      expect(f.when({ value: 80, row: { id: 'b', price: 80 } })).toBe(false)
-    }
-  })
-
-  it('scopes to the event column when no explicit columns', () => {
-    const formats = toConditionalFormats([event({ columnId: 'price' })], getRowId)
-    const f = formats[0]!
-    if (f.type === 'rule') expect(f.columns).toEqual(['price'])
-  })
-
-  it('honours explicit action columns', () => {
-    const formats = toConditionalFormats(
-      [event({ actions: [{ kind: 'badge', columns: ['price', 'id'], style: { background: '#fff' } }] })],
-      getRowId,
-    )
-    const f = formats[0]!
-    if (f.type === 'rule') expect(f.columns).toEqual(['price', 'id'])
-  })
-
-  it('ignores toast/log/flash-only events (no styling)', () => {
-    expect(toConditionalFormats([event({ actions: [{ kind: 'toast' }, { kind: 'log' }] })], getRowId)).toHaveLength(0)
-  })
-
-  it('skips events without a row id', () => {
-    expect(toConditionalFormats([event({ rowId: undefined })], getRowId)).toHaveLength(0)
-  })
-})
-
-describe('rulesToConditionalFormats', () => {
-  const rule = (over: Partial<AlertRule> = {}): AlertRule => ({
-    id: 'r1',
-    name: 'High',
-    enabled: true,
-    severity: 'warning',
-    scope: 'row',
-    predicate: { kind: 'cmp', column: 'price', op: 'greaterThan', value: 100 },
-    trigger: { type: 'dataChange' },
-    actions: [{ kind: 'highlight', style: { background: '#fee2e2' } }],
-    createdAt: 0,
-    ...over,
-  })
-
-  it('emits one live predicate-driven format per styling rule', () => {
-    const formats = rulesToConditionalFormats<Row>([rule()])
-    expect(formats).toHaveLength(1)
-    const f = formats[0]!
-    if (f.type === 'rule') {
-      expect(f.when({ value: 0, row: { id: 'a', price: 120 } })).toBe(true)
-      expect(f.when({ value: 0, row: { id: 'b', price: 80 } })).toBe(false)
-    }
-  })
-
-  it('ignores disabled rules and non-styling rules', () => {
-    expect(rulesToConditionalFormats<Row>([rule({ enabled: false })])).toHaveLength(0)
-    expect(rulesToConditionalFormats<Row>([rule({ actions: [{ kind: 'toast' }] })])).toHaveLength(0)
-  })
-})

package/src/alerts/alert-formats.ts

@@ -1,77 +0,0 @@
-/**
- * Bridge fired alert events to the grid's conditional-formatting engine. A
- * `badge` / `highlight` action becomes a `RuleFormat` whose `when` matches the
- * row that fired, so `resolveCellFormat` paints it - the same painter the grid
- * already uses for color scales and data bars. No new rendering path.
- */
-import type { ConditionalFormat } from '@svgrid/grid/format'
-import { evaluatePredicate } from '../expressions/evaluate'
-import type { AlertEvent, AlertRule } from './alert-types'
-
-/** Which action kinds paint onto cells. */
-const STYLING_KINDS = new Set(['badge', 'highlight'])
-
-export type StylingContext<TData> = {
-  getValue?: (row: TData, columnId: string) => unknown
-  locale?: string | ReadonlyArray<string>
-}
-
-/**
- * Persistent styling: one self-contained `RuleFormat` per enabled rule that has
- * a `badge`/`highlight` action. The format's `when` runs the rule predicate
- * directly, so the styling stays live as data changes (rows light up while they
- * match and clear when they stop) without any row-id bookkeeping. One format
- * per rule keeps the array tiny regardless of row count.
- */
-export function rulesToConditionalFormats<TData = Record<string, unknown>>(
-  rules: ReadonlyArray<AlertRule>,
-  ctx: StylingContext<TData> = {},
-): ConditionalFormat<TData>[] {
-  const formats: ConditionalFormat<TData>[] = []
-  for (const rule of rules) {
-    if (!rule.enabled) continue
-    for (const action of rule.actions) {
-      if (!STYLING_KINDS.has(action.kind)) continue
-      const columns = action.columns ?? rule.columns
-      const style = action.style ?? {}
-      formats.push({
-        type: 'rule',
-        ...(columns ? { columns } : {}),
-        when: ({ row }: { value: unknown; row: TData }) =>
-          evaluatePredicate(rule.predicate, { row, getValue: ctx.getValue, locale: ctx.locale }),
-        ...(style.background ? { background: style.background } : {}),
-        ...(style.color ? { color: style.color } : {}),
-      })
-    }
-  }
-  return formats
-}
-
-/**
- * Turn active alert events into conditional formats. Events whose actions only
- * toast/log/flash contribute nothing here. Matching is by row id, so the format
- * follows the row through sort/filter rather than a fixed index.
- */
-export function toConditionalFormats<TData = Record<string, unknown>>(
-  events: ReadonlyArray<AlertEvent>,
-  getRowId: (row: TData) => string,
-): ConditionalFormat<TData>[] {
-  const formats: ConditionalFormat<TData>[] = []
-  for (const event of events) {
-    if (event.rowId == null) continue
-    const rowId = event.rowId
-    for (const action of event.actions) {
-      if (!STYLING_KINDS.has(action.kind)) continue
-      const columns = action.columns ?? (event.columnId ? [event.columnId] : undefined)
-      const style = action.style ?? {}
-      formats.push({
-        type: 'rule',
-        ...(columns ? { columns } : {}),
-        when: ({ row }: { value: unknown; row: TData }) => getRowId(row) === rowId,
-        ...(style.background ? { background: style.background } : {}),
-        ...(style.color ? { color: style.color } : {}),
-      })
-    }
-  }
-  return formats
-}

package/src/alerts/alert-observer.test.ts

@@ -1,189 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { createAlertEngine } from './alert-engine'
-import { createAlertObserver } from './alert-observer'
-import { createAlertScheduler } from './alert-scheduler'
-import type { AlertEvent, AlertRule } from './alert-types'
-
-type Row = { id: string; price: number; region: string; status: string }
-
-const seedRows = (over: Partial<Row>[] = []): Row[] =>
-  [
-    { id: 'a', price: 120, region: 'EU', status: 'open' },
-    { id: 'b', price: 80, region: 'US', status: 'open' },
-  ].map((r, i) => ({ ...r, ...(over[i] ?? {}) }))
-
-const getRowId = (r: Row) => r.id
-
-const dataChangeRule: AlertRule = {
-  id: 'r1',
-  name: 'High price',
-  enabled: true,
-  severity: 'warning',
-  scope: 'row',
-  predicate: { kind: 'cmp', column: 'price', op: 'greaterThan', value: 100 },
-  trigger: { type: 'dataChange' },
-  actions: [{ kind: 'toast', message: '{region} at {value}' }],
-  createdAt: 0,
-}
-
-const relativeRule: AlertRule = {
-  id: 'r2',
-  name: 'Jumped',
-  enabled: true,
-  severity: 'info',
-  scope: 'row',
-  predicate: { kind: 'const', value: true },
-  trigger: { type: 'relativeChange', expr: { kind: 'percentChange', column: 'price', op: '>', value: 5, abs: true } },
-  actions: [{ kind: 'toast', message: 'moved' }],
-  createdAt: 0,
-}
-
-function harness(rules: AlertRule[]) {
-  const engine = createAlertEngine<Row>({ rules, getRowId, now: () => 1000 })
-  const events: AlertEvent[] = []
-  const observer = createAlertObserver<Row>({
-    engine,
-    getRowId,
-    schedule: 'sync', // deterministic: runs inline
-    onEvents: (batch) => events.push(...batch),
-  })
-  return { engine, observer, events }
-}
-
-describe('engine.needsPrev / needsFullSet', () => {
-  it('needsPrev is true only when a relativeChange rule is enabled', () => {
-    expect(createAlertEngine<Row>({ rules: [dataChangeRule], getRowId }).needsPrev()).toBe(false)
-    expect(createAlertEngine<Row>({ rules: [relativeRule], getRowId }).needsPrev()).toBe(true)
-    expect(
-      createAlertEngine<Row>({ rules: [{ ...relativeRule, enabled: false }], getRowId }).needsPrev(),
-    ).toBe(false)
-  })
-
-  it('needsFullSet is true only when an aggregate-scope rule is enabled', () => {
-    expect(createAlertEngine<Row>({ rules: [dataChangeRule], getRowId }).needsFullSet()).toBe(false)
-    const agg: AlertRule = { ...dataChangeRule, id: 'agg', scope: 'aggregate' }
-    expect(createAlertEngine<Row>({ rules: [agg], getRowId }).needsFullSet()).toBe(true)
-  })
-})
-
-describe('createAlertObserver push mode', () => {
-  it('seed is silent - pre-existing matches do not fire', () => {
-    const { observer, events } = harness([dataChangeRule])
-    observer.seed(seedRows()) // 'a' already > 100
-    expect(events).toHaveLength(0)
-  })
-
-  it('pushChanged fires only for the rows it is given, once on crossing', () => {
-    const { observer, events } = harness([dataChangeRule])
-    observer.seed(seedRows([{ price: 90 }])) // 'a' starts below threshold
-    // 'b' unchanged and below threshold; push 'a' now crossing.
-    observer.pushChanged([{ id: 'a', price: 130, region: 'EU', status: 'open' }])
-    expect(events).toHaveLength(1)
-    expect(events[0]!.rowId).toBe('a')
-    // Pushing it again while it stays above must not re-fire (edge memory).
-    observer.pushChanged([{ id: 'a', price: 131, region: 'EU', status: 'open' }])
-    expect(events).toHaveLength(1)
-  })
-
-  it('does not evaluate rows that were never pushed', () => {
-    const { observer, events } = harness([dataChangeRule])
-    observer.seed(seedRows([{ price: 90 }, { price: 95 }])) // both below
-    // Only 'b' is pushed, crossing the line; 'a' is untouched.
-    observer.pushChanged([{ id: 'b', price: 150, region: 'US', status: 'open' }])
-    expect(events).toHaveLength(1)
-    expect(events[0]!.rowId).toBe('b')
-  })
-
-  it('relativeChange push sees prev via the maintained snapshot', () => {
-    const { observer, events } = harness([relativeRule])
-    const start = seedRows()
-    observer.seed(start)
-    // 'a' 120 -> 140 is +16% -> fires.
-    observer.pushChanged([{ id: 'a', price: 140, region: 'EU', status: 'open' }])
-    expect(events).toHaveLength(1)
-    expect(events[0]!.columnId).toBe('price')
-  })
-})
-
-describe('createAlertObserver scales O(changed), not O(total)', () => {
-  it('a push over a 100k seed touches only the changed rows', () => {
-    // Seed 100k rows, then push a handful. The evaluation must not re-scan the
-    // whole set - we assert by counting getRowId calls after the seed.
-    let calls = 0
-    const countingId = (r: Row) => {
-      calls++
-      return r.id
-    }
-    const engine = createAlertEngine<Row>({ rules: [dataChangeRule], getRowId: countingId, now: () => 1000 })
-    const events: AlertEvent[] = []
-    const observer = createAlertObserver<Row>({
-      engine,
-      getRowId: countingId,
-      schedule: 'sync',
-      onEvents: (b) => events.push(...b),
-    })
-
-    const big: Row[] = Array.from({ length: 100_000 }, (_, i) => ({
-      id: `r${i}`,
-      price: 10, // all below the >100 threshold
-      region: 'EU',
-      status: 'open',
-    }))
-    observer.seed(big)
-    calls = 0 // ignore the one-time seed cost; measure only the push
-
-    observer.pushChanged([{ id: 'r5', price: 130, region: 'EU', status: 'open' }])
-    expect(events).toHaveLength(1)
-    expect(events[0]!.rowId).toBe('r5')
-    // O(changed): a single changed row costs a bounded handful of id lookups,
-    // nowhere near the 100k total.
-    expect(calls).toBeLessThan(50)
-  })
-})
-
-describe('createAlertObserver scan (watch) mode', () => {
-  it('index-diffs the array and evaluates only changed rows', () => {
-    const { observer, events } = harness([dataChangeRule])
-    let data: Row[] = seedRows([{ price: 90 }]) // 'a' below
-    observer.scan(() => data) // first scan seeds silently
-    expect(events).toHaveLength(0)
-    // Immutable replace of 'a' only (Svelte-5 style).
-    data = [{ ...data[0]!, price: 130 }, data[1]!]
-    observer.scan(() => data)
-    expect(events).toHaveLength(1)
-    expect(events[0]!.rowId).toBe('a')
-  })
-})
-
-describe('createScheduler', () => {
-  it('sync mode runs immediately', () => {
-    const s = createAlertScheduler('sync')
-    const fn = vi.fn()
-    s.schedule(fn)
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(s.pending).toBe(false)
-  })
-
-  it('coalesces multiple schedules and flush runs the latest once', () => {
-    const s = createAlertScheduler('raf') // no rAF in node -> setTimeout fallback, but flush is sync
-    const a = vi.fn()
-    const b = vi.fn()
-    s.schedule(a)
-    s.schedule(b)
-    expect(s.pending).toBe(true)
-    s.flush()
-    // Latest wins - only the most recent callback runs, exactly once.
-    expect(a).not.toHaveBeenCalled()
-    expect(b).toHaveBeenCalledTimes(1)
-    expect(s.pending).toBe(false)
-  })
-
-  it('cancel drops the pending callback', () => {
-    const s = createAlertScheduler('raf')
-    const fn = vi.fn()
-    s.schedule(fn)
-    s.cancel()
-    s.flush()
-    expect(fn).not.toHaveBeenCalled()
-  })
-})