@object-ui/core 17.3.0 → 17.5.0

package/dist/utils/normalize-list-view.js

@@ -32,17 +32,39 @@ export const ROW_HEIGHT_TO_DENSITY_MODE = {
     extra_tall: 'spacious',
 };
 /**
- * Tolerant reader for {@link ROW_HEIGHT_TO_DENSITY_MODE}. View metadata is
- * user-authored, so `rowHeight` is not guaranteed to be one of the five spec
- * values — an unknown one lands on `comfortable` rather than rendering an
- * undefined density. Keeping the fallback here means every surface collapses
- * the same way.
+ * Runtime reader for {@link ROW_HEIGHT_TO_DENSITY_MODE}: the spec's five row
+ * heights narrowed onto the renderer's three densities, and **nothing else**.
+ *
+ * The parameter stays `unknown` because this is the boundary user-authored view
+ * metadata actually crosses — `ListViewSchema.rowHeight` is statically a
+ * `RowHeight`, but the value arrives from stored view definitions TypeScript
+ * never saw (`ObjectView`: `viewDef.rowHeight ?? listSchema.rowHeight`). The
+ * type-level half of the guarantee is the `Record<RowHeight, …>` on the table
+ * above, which fails the build when the spec grows a row height.
+ *
+ * An off-spec value gets NO density (objectui#4440). It used to be coerced to
+ * `comfortable`, which is the opposite of what `@object-ui/react`'s spec bridge
+ * answers for the same string after objectui#4352 — one metadata-driven system
+ * holding two answers for one input. AGENTS.md #0.1 decides which one survives:
+ * a renderer-side rehabilitation of off-spec metadata is a second de-facto
+ * contract, and one strict contract beats N. The producer is where a bad
+ * `rowHeight` gets fixed.
+ *
+ * Callers apply their own "nothing was said" default to `undefined`, so an
+ * off-spec row height now renders exactly like an absent one — `'compact'` in
+ * both `ListView` and `ObjectGrid`.
+ *
+ * `hasOwnProperty`, not `in`: `in` walks the prototype chain, so `'toString'`
+ * used to come back as `Object.prototype.toString` — a FUNCTION returned from
+ * something typed `DensityMode`.
  */
 export function rowHeightToDensityMode(rowHeight) {
-    if (typeof rowHeight === 'string' && rowHeight in ROW_HEIGHT_TO_DENSITY_MODE) {
-        return ROW_HEIGHT_TO_DENSITY_MODE[rowHeight];
+    if (typeof rowHeight !== 'string')
+        return undefined;
+    if (!Object.prototype.hasOwnProperty.call(ROW_HEIGHT_TO_DENSITY_MODE, rowHeight)) {
+        return undefined;
     }
-    return 'comfortable';
+    return ROW_HEIGHT_TO_DENSITY_MODE[rowHeight];
 }
 const isRecord = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 /**

package/dist/utils/number-display.d.ts

@@ -0,0 +1,151 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * `formatDisplayNumber` — the ONE number-display formatter behind every field
+ * cell, field widget, metric renderer and dataset measure in the console.
+ *
+ * It exists because the same `new Intl.NumberFormat('en-US', …)` construction
+ * had been copied into the number cell renderer, the currency cell renderer,
+ * the currency widget, the compact `formatNumber` helper and the dashboard
+ * metric widget. Two defects therefore had five homes each, and fixing "the"
+ * renderer never changed the answer (objectui#4033, source thread
+ * objectstack#5067):
+ *
+ *  1. the locale was hardcoded to `en-US`, so a `zh-CN` / `de-DE` console still
+ *     grouped and pointed decimals the US way; and
+ *  2. `useGrouping` was never set, so a four-digit YEAR stored as
+ *     `Field.number({ scale: 0 })` rendered as `2,026` — in every locale, with
+ *     no field property able to turn it off.
+ *
+ * Both policies now live here and nowhere else. Call sites bring the value and
+ * the display width; they do not bring a locale default and they do not decide
+ * grouping.
+ *
+ * ── Why this module lives in `@object-ui/core` (objectui#4576) ──
+ * It used to live in `@object-ui/i18n`, and that home cost the repo a real
+ * defect. `@object-ui/core`'s `utils/dataset-format.ts` could not import it —
+ * `core` is the React-free engine (AGENTS.md §3: "No UI-lib deps. Logic only.")
+ * and is a runtime dependency of React-FREE consumers (the `object-ui` VS Code
+ * extension, `@object-ui/data-objectstack`), while `i18n` depends on
+ * `i18next`/`react-i18next` and peer-depends on React. So `formatMeasure` kept
+ * a parallel `Intl` implementation, the two drifted, and a German session read
+ * `1.234,5 %` from a list cell beside `1.234,5%` from a dashboard measure
+ * (objectui#4576). #4577 measured the option mapping LOSSLESS across 32,760
+ * combinations and recorded the duplication at both ends rather than routing
+ * through a boundary it could not cross.
+ *
+ * The function is pure — no React, no i18next, no DOM — so the boundary was
+ * never a property of the CODE, only of where the code sat. Moving it DOWN to
+ * the lower layer removes the obstacle instead of working around it:
+ * `@object-ui/i18n` now RE-EXPORTS these three names, so every existing import
+ * path keeps compiling and `import { formatDisplayNumber } from '@object-ui/i18n'`
+ * and `from '@object-ui/core'` are the SAME symbol (pinned in
+ * `packages/i18n/src/__tests__/number-display.reexport-identity.test.ts`).
+ * `core` imports `i18n` nowhere, so the new edge introduces no cycle.
+ */
+export interface DisplayNumberFormatOptions {
+    /**
+     * BCP-47 tag for the ACTIVE display locale — in React, whatever
+     * `useDisplayLocale()` returns.
+     *
+     * `undefined` means "follow the runtime default", which is the honest answer
+     * for a non-React caller that has no locale in hand. It never means `en-US`:
+     * assuming US conventions for the whole world is the defect this module was
+     * created to remove.
+     */
+    locale?: string;
+    /**
+     * ISO 4217 code. When present the value is formatted as money — which also
+     * means grouping is kept, because a grouped amount is what every currency
+     * convention expects and an ordinal amount of money is not a thing.
+     *
+     * Money wins over {@link DisplayNumberFormatOptions.style}: a call that sets
+     * both gets a currency rendering. Nothing in the repo does that, and the
+     * combination has no meaning to express.
+     */
+    currency?: string;
+    /**
+     * The FIELD's declared `scale` — the `s` of a `decimal(p, s)` column — and
+     * nothing else. This is a POLICY input, not a display width: pass it only
+     * when a field declaration actually said so.
+     *
+     * `scale: 0` with no currency declares a discrete integer (a year, a fiscal
+     * period, an ordinal), and those are not grouped. Leave `scale` undefined and
+     * grouping is kept — which is correct for the two cases that look similar but
+     * are not:
+     *
+     *   - an UNDECLARED scale (`scale` is optional in the spec, so absent means
+     *     "decimals unknown", not "integer"); and
+     *   - a caller whose zero-decimal display comes from something other than a
+     *     field declaration — e.g. the dashboard `MetricWidget`, whose decimals
+     *     come from a numeral.js format pattern and whose large KPI aggregates
+     *     are *documented* to want separators ("`1,930,000` not `1930000`").
+     *
+     * ⚠️ INTERIM DEFAULT (objectui#4033, PM ruling 2026-08-11). Suppressing
+     * grouping for every scale-0 number is a transitional policy with a known,
+     * accepted cost: a large scale-0 COUNT loses its separators too. It is the
+     * better trade only until the spec gains an authorable presentation hint
+     * (`useGrouping` / `displayFormat` — being specified separately, contract-first,
+     * in the objectstack repo). When that hint lands it OVERRIDES this default,
+     * and this heuristic should be reduced to the fallback for fields that
+     * declare nothing.
+     */
+    scale?: number;
+    /**
+     * How the number relates to a percentage — the ONE place that distinction is
+     * expressed, because getting it wrong is the whole of objectui#4576.
+     *
+     *  - `'decimal'` (default) — a plain number, no percent sign.
+     *  - `'percent'` — the value is a FRACTION. `Intl` multiplies it by 100 and
+     *    appends the locale's percent convention, so `0.8` renders as `80%`.
+     *  - `'percentPoints'` — the value is ALREADY in percentage points, so `80`
+     *    renders as `80%`. Same locale convention, NO re-scaling.
+     *
+     * The third one exists because "divide by 100 so `Intl` can multiply it back"
+     * is not free, and the round trip is lossy at rounding TIES: measured on this
+     * repo's runner, `80.175` percentage points formatted to 2 decimals renders
+     * `80.18%` when formatted directly and `80.17%` after the divide-and-remultiply
+     * — 27,581 of 1,200,013 ordinary-magnitude en-US forms move, plus every
+     * value at the top of the double range (`MAX_SAFE_INTEGER`, `1e23`). A caller
+     * holding percentage points must therefore NOT reach for `'percent'`; that is
+     * exactly the trap this option removes.
+     *
+     * `'percentPoints'` is implemented with `Intl`'s `style: 'unit'` /
+     * `unit: 'percent'`, which was measured to produce a BYTE-IDENTICAL percent
+     * affix to `style: 'percent'` across all 171 locale tags tested — including
+     * the German/French/Russian no-break space before the sign, Turkish's PREFIX
+     * position (`%1.234,5`), Arabic's own percent sign plus U+061C, and the
+     * Bengali/Marathi percent patterns that group Western-style where their
+     * decimal patterns group by lakh. It is the same CONVENTION by a route that
+     * does not touch the value.
+     */
+    style?: 'decimal' | 'percent' | 'percentPoints';
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    notation?: 'standard' | 'compact';
+}
+/**
+ * The grouping policy, alone and testable: does this number get thousands
+ * separators?
+ *
+ * @param scale    the field's declared `scale`, or `undefined` when the caller
+ *                 has no field declaration behind it
+ * @param currency ISO 4217 code when the number is money
+ */
+export declare function shouldGroupDisplayNumber(scale?: number, currency?: string): boolean;
+/**
+ * Format a number for DISPLAY, in the active locale, under the grouping policy
+ * above.
+ *
+ * Throws for a bad `currency` code exactly as `Intl.NumberFormat` does, so the
+ * fallbacks call sites already had (`${currency} ${value.toFixed(n)}`) keep
+ * working unchanged. A bad LOCALE is handled here instead of throwing: `locale`
+ * arrives from a server response (ADR-0053 `localization.locale`), and a
+ * malformed tag from a tenant config must never take a grid cell down.
+ */
+export declare function formatDisplayNumber(value: number, options?: DisplayNumberFormatOptions): string;

package/dist/utils/number-display.js

@@ -0,0 +1,71 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The grouping policy, alone and testable: does this number get thousands
+ * separators?
+ *
+ * @param scale    the field's declared `scale`, or `undefined` when the caller
+ *                 has no field declaration behind it
+ * @param currency ISO 4217 code when the number is money
+ */
+export function shouldGroupDisplayNumber(scale, currency) {
+    // Money always groups — including money whose currency code could not be
+    // resolved, which still renders as an amount (just without a symbol).
+    if (currency)
+        return true;
+    // Only an explicitly declared scale of 0 is an ordinal. `undefined !== 0`.
+    return scale !== 0;
+}
+/**
+ * Format a number for DISPLAY, in the active locale, under the grouping policy
+ * above.
+ *
+ * Throws for a bad `currency` code exactly as `Intl.NumberFormat` does, so the
+ * fallbacks call sites already had (`${currency} ${value.toFixed(n)}`) keep
+ * working unchanged. A bad LOCALE is handled here instead of throwing: `locale`
+ * arrives from a server response (ADR-0053 `localization.locale`), and a
+ * malformed tag from a tenant config must never take a grid cell down.
+ */
+export function formatDisplayNumber(value, options = {}) {
+    const { locale, currency, scale, style, ...passthrough } = options;
+    const intlOptions = { ...passthrough };
+    if (style === 'percentPoints') {
+        // The locale's percent convention WITHOUT `style: 'percent'`'s ×100 — see
+        // the option's doc above for the measurement that separates the two.
+        intlOptions.style = 'unit';
+        intlOptions.unit = 'percent';
+        intlOptions.unitDisplay = 'narrow';
+    }
+    else if (style) {
+        intlOptions.style = style;
+    }
+    if (currency) {
+        intlOptions.style = 'currency';
+        intlOptions.currency = currency;
+        delete intlOptions.unit;
+        delete intlOptions.unitDisplay;
+    }
+    // ⚠️ Set `useGrouping` ONLY to suppress. `useGrouping: true` is NOT the same
+    // as omitting the key: `true` means "always", while omitting it means "auto"
+    // (and "min2" under compact notation), which is the locale's own preference.
+    // Measured — for 1234: es-ES "auto" → `1234` but "always" → `1.234`; pl-PL
+    // "auto" → `1234` but "always" → `1 234`. Writing `true` here would silently
+    // override those locales' conventions in the name of preserving en-US output.
+    if (!shouldGroupDisplayNumber(scale, currency)) {
+        intlOptions.useGrouping = false;
+    }
+    try {
+        return new Intl.NumberFormat(locale, intlOptions).format(value);
+    }
+    catch {
+        // Retry WITHOUT the locale, keeping every other option: this rescues a
+        // malformed tag while still surfacing a genuinely bad `currency` to the
+        // caller's own catch.
+        return new Intl.NumberFormat(undefined, intlOptions).format(value);
+    }
+}

package/dist/utils/resolve-view-id.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resolve a REQUESTED view name against an object's actual view ids.
+ *
+ * Canonical view ids are fully qualified (`<object>.<viewKind>`, see app-shell's
+ * MetadataProvider), but the surfaces that NAME a view emit the short form —
+ * nav items write their `viewName` verbatim, `ElementDataSource.view` on a page
+ * component is authored by hand, and legacy embedded `listViews` carry bare keys
+ * (including the `'all'` fallback view). Accept both directions (#2217):
+ *
+ * 1. exact id match;
+ * 2. short name (no `.`) → retry as `<objectName>.<name>`;
+ * 3. qualified name → retry with the `<objectName>.` prefix stripped.
+ *
+ * Returns the matching view id, or `undefined` when nothing matches — the
+ * caller decides how to fall back (and should report it rather than swallow it).
+ *
+ * Lives in `@object-ui/core` because it has two consumers in different layers:
+ * app-shell's `ObjectView` (URL-requested view) and the page-component data
+ * binding that resolves `dataSource.view` (objectstack#5576). A second copy at
+ * the second call site is the drift AGENTS.md #0.1 forbids — one matcher, one
+ * place, so a view name that resolves in the object page resolves identically
+ * when a page component names it.
+ */
+export declare function resolveViewId(requested: string | undefined | null, viewIds: readonly string[], objectName: string): string | undefined;

package/dist/utils/resolve-view-id.js

@@ -0,0 +1,45 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resolve a REQUESTED view name against an object's actual view ids.
+ *
+ * Canonical view ids are fully qualified (`<object>.<viewKind>`, see app-shell's
+ * MetadataProvider), but the surfaces that NAME a view emit the short form —
+ * nav items write their `viewName` verbatim, `ElementDataSource.view` on a page
+ * component is authored by hand, and legacy embedded `listViews` carry bare keys
+ * (including the `'all'` fallback view). Accept both directions (#2217):
+ *
+ * 1. exact id match;
+ * 2. short name (no `.`) → retry as `<objectName>.<name>`;
+ * 3. qualified name → retry with the `<objectName>.` prefix stripped.
+ *
+ * Returns the matching view id, or `undefined` when nothing matches — the
+ * caller decides how to fall back (and should report it rather than swallow it).
+ *
+ * Lives in `@object-ui/core` because it has two consumers in different layers:
+ * app-shell's `ObjectView` (URL-requested view) and the page-component data
+ * binding that resolves `dataSource.view` (objectstack#5576). A second copy at
+ * the second call site is the drift AGENTS.md #0.1 forbids — one matcher, one
+ * place, so a view name that resolves in the object page resolves identically
+ * when a page component names it.
+ */
+export function resolveViewId(requested, viewIds, objectName) {
+    if (!requested)
+        return undefined;
+    const has = (id) => viewIds.includes(id);
+    if (has(requested))
+        return requested;
+    const prefix = `${objectName}.`;
+    if (!requested.includes('.') && has(prefix + requested)) {
+        return prefix + requested;
+    }
+    if (requested.startsWith(prefix) && has(requested.slice(prefix.length))) {
+        return requested.slice(prefix.length);
+    }
+    return undefined;
+}

package/dist/utils/sort-query.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * sort-query — lower a block's authored `sort` to the `$orderby` value a
+ * `DataSource.find` query carries.
+ *
+ * Two authored spellings reach every object-bound block, because both are
+ * declared: the legacy OData-ish string (`ObjectGridSchema.sort: "name desc"`)
+ * and the spec's `SortConfig[]` (`[{ field, order }]`). A read site that hands
+ * either straight to `$orderby` works only because `QueryParams.$orderby`
+ * accepts four shapes; normalizing here means one shape reaches the wire and a
+ * block does not have to know which spelling its author used.
+ *
+ * This is the same conversion three sibling blocks already inline privately
+ * (`ObjectGantt` / `ObjectMap` / `ObjectCalendar`, byte-identical copies). It is
+ * hoisted here because objectstack#7137 added two more read sites
+ * (`object-timeline`, `record:line_items`), and a fifth and sixth private copy is
+ * how the conversions start disagreeing. Collapsing the three existing copies
+ * onto this one is deliberately NOT part of #7137 — it is tracked as
+ * objectstack#7148.
+ *
+ * Two deliberate differences from those private copies, both of which make this
+ * function more faithful to the declared contract rather than adding tolerance:
+ *
+ *  - **`order` is optional in `SortConfig`**, so an entry that omits it means
+ *    ascending (that is what `$orderby`'s own
+ *    `Array<{ field: string; order?: 'asc' | 'desc' }>` shape says). The private
+ *    copies require BOTH keys and silently drop such an entry, which loses an
+ *    authored sort key instead of ordering by it.
+ *  - **Nothing usable yields `undefined`, never `{}`.** An empty object is a
+ *    truthy value that means "no ordering" only by accident of the adapter's
+ *    serializer; `undefined` says it, so the query simply carries no `$orderby`.
+ *
+ * Not a lenient alias: an unusable input (a number, an object, an array of
+ * strings) yields `undefined` rather than a guess. Only the two spellings the
+ * schema types declare are honoured.
+ */
+/** A field name paired with a direction — the spec's `SortConfig`. */
+export interface QuerySortEntry {
+    field?: string;
+    order?: 'asc' | 'desc';
+}
+/**
+ * Normalize an authored `sort` into the field→direction map used for
+ * `QueryParams.$orderby`.
+ *
+ * @param sort `"name desc"` (legacy string) or `SortConfig[]`.
+ * @returns The ordering map, or `undefined` when nothing orderable was authored.
+ */
+export declare function convertSortToQueryParams(sort: string | QuerySortEntry[] | undefined | null): Record<string, 'asc' | 'desc'> | undefined;

package/dist/utils/sort-query.js

@@ -0,0 +1,35 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Normalize an authored `sort` into the field→direction map used for
+ * `QueryParams.$orderby`.
+ *
+ * @param sort `"name desc"` (legacy string) or `SortConfig[]`.
+ * @returns The ordering map, or `undefined` when nothing orderable was authored.
+ */
+export function convertSortToQueryParams(sort) {
+    if (!sort)
+        return undefined;
+    // Legacy string clause: "name desc" / "name" (a bare field means ascending).
+    if (typeof sort === 'string') {
+        const [field, direction] = sort.trim().split(/\s+/);
+        if (!field)
+            return undefined;
+        return { [field]: direction?.toLowerCase() === 'desc' ? 'desc' : 'asc' };
+    }
+    if (Array.isArray(sort)) {
+        const out = {};
+        for (const entry of sort) {
+            if (!entry || typeof entry.field !== 'string' || entry.field === '')
+                continue;
+            out[entry.field] = entry.order === 'desc' ? 'desc' : 'asc';
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/core",
-  "version": "17.3.0",
+  "version": "17.5.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -25,11 +25,11 @@
     }
   },
   "dependencies": {
-    "@objectstack/formula": "^17.0.0-rc.2",
-    "@objectstack/spec": "^17.0.0-rc.2",
+    "@objectstack/formula": "^17.0.0-rc.6",
+    "@objectstack/spec": "^17.0.0-rc.6",
     "lodash": "^4.18.1",
     "zod": "^4.4.3",
-    "@object-ui/types": "17.3.0"
+    "@object-ui/types": "17.5.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
@@ -62,7 +62,7 @@
   "scripts": {
     "build": "tsc",
     "test": "vitest run",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc --noEmit && tsc -p tsconfig.test.json",
     "lint": "eslint ."
   }
 }

package/dist/utils/merge-views-into-objects.d.ts

@@ -1,19 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Adapter: merge stack-level views into object definitions.
- *
- * Views are defined at the stack level (views[].listViews) but the runtime
- * expects listViews on each object definition. This bridges the gap until
- * the runtime/provider layer handles it natively.
- *
- * @param objects - Object definitions from composed stack
- * @param views   - View definitions containing listViews keyed by object name
- * @returns Objects with listViews merged in from matching views
- */
-export declare function mergeViewsIntoObjects(objects: any[], views: any[]): any[];

package/dist/utils/merge-views-into-objects.js

@@ -1,39 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Adapter: merge stack-level views into object definitions.
- *
- * Views are defined at the stack level (views[].listViews) but the runtime
- * expects listViews on each object definition. This bridges the gap until
- * the runtime/provider layer handles it natively.
- *
- * @param objects - Object definitions from composed stack
- * @param views   - View definitions containing listViews keyed by object name
- * @returns Objects with listViews merged in from matching views
- */
-export function mergeViewsIntoObjects(objects, views) {
-    const viewsByObject = {};
-    for (const view of views) {
-        if (!view.listViews)
-            continue;
-        for (const [viewName, listView] of Object.entries(view.listViews)) {
-            const objectName = listView?.data?.object;
-            if (!objectName)
-                continue;
-            if (!viewsByObject[objectName])
-                viewsByObject[objectName] = {};
-            viewsByObject[objectName][viewName] = listView;
-        }
-    }
-    return objects.map((obj) => {
-        const v = viewsByObject[obj.name];
-        if (!v)
-            return obj;
-        return { ...obj, listViews: { ...(obj.listViews || {}), ...v } };
-    });
-}