@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/kbd-children-no-modifier-text.js

@@ -1,128 +0,0 @@
-/*
- * A shortcut hint is `<Kbd meta>K</Kbd>`: the modifier is a flag, the child is
- * one key from `KBD_KEYS`, and the component draws the person's platform. A
- * hand-written ⌘ or "Ctrl" is right on one platform and wrong on the others.
- *
- * Standard tool checked first: `no-restricted-syntax` can match a `Kbd` child
- * by text, but not whether this `Kbd` is the package's (an import binding, so a
- * renamed or local `Kbd` is judged correctly), and it would need the key list
- * spelled into a regex. The list is read from the package's own `KBD_KEYS`
- * array at lint time, so a key added there changes this rule's answer with no
- * edit here.
- */
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
-import { packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const KBD_MODULE = "@nadicodeai/ui/components/kbd";
-const OWNER_FILE = "packages/ui/src/components/kbd.tsx";
-
-const KBD = new Map([["Kbd", packageModules("kbd").map((from) => ({ from, part: "Kbd" }))]]);
-
-/*
- * TypeScript is loaded when this rule first runs, not when the plugin loads:
- * the plugin ships inside `@nadicodeai/ui`, which does not depend on the
- * compiler, and a consumer who never enables this rule never asks for it.
- */
-let ts;
-function typescript() {
-  ts ??= createRequire(import.meta.url)("typescript");
-  return ts;
-}
-
-function arrayLiteralOf(ts, expression) {
-  let node = expression;
-  while (
-    node &&
-    (ts.isAsExpression(node) ||
-      ts.isSatisfiesExpression(node) ||
-      ts.isParenthesizedExpression(node))
-  ) {
-    node = node.expression;
-  }
-  return node && ts.isArrayLiteralExpression(node) ? node : null;
-}
-
-function readKeys() {
-  const ts = typescript();
-  const file = fileURLToPath(import.meta.resolve(KBD_MODULE));
-  const source = ts.createSourceFile(
-    file,
-    readFileSync(file, "utf8"),
-    ts.ScriptTarget.Latest,
-    false,
-    file.endsWith(".js") ? ts.ScriptKind.JS : ts.ScriptKind.TSX,
-  );
-  for (const statement of source.statements) {
-    if (!ts.isVariableStatement(statement)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || declaration.name.text !== "KBD_KEYS") continue;
-      const array = arrayLiteralOf(ts, declaration.initializer);
-      if (!array) break;
-      return new Set(array.elements.map((element) => element.text));
-    }
-  }
-  throw new Error(`${file} has no KBD_KEYS array literal to read the keys from.`);
-}
-
-let keys;
-
-/** Read once per lint process; the built module does not move under it. */
-function kbdKeys() {
-  keys ??= readKeys();
-  return keys;
-}
-
-function writtenText(child) {
-  if (child.type === "JSXText") return child.value.trim() === "" ? null : child.value.trim();
-  if (child.type !== "JSXExpressionContainer") return null;
-  const { expression } = child;
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-  if (expression.type === "Literal" && typeof expression.value === "string") {
-    return expression.value;
-  }
-  if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return expression.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-export const kbdChildrenNoModifierText = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Kbd child is one key from KBD_KEYS with the modifier as a flag, and a shortcut is never a lowercase kbd element.",
-    },
-    schema: [],
-    messages: {
-      "hand-written-key":
-        "Write the modifier as a flag, <Kbd meta>K</Kbd>, and the child as one key from KBD_KEYS. A hand-written glyph shows the wrong key on Windows and Linux.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const ownsTheElement = context.filename.replaceAll("\\", "/").endsWith(`/${OWNER_FILE}`);
-
-    return {
-      JSXElement(node) {
-        const name = node.openingElement.name;
-        if (name.type === "JSXIdentifier" && name.name === "kbd") {
-          if (!ownsTheElement) {
-            context.report({ node: node.openingElement, messageId: "hand-written-key" });
-          }
-          return;
-        }
-        if (partOf(importOf(name), KBD, context.filename) !== "Kbd") return;
-        for (const child of node.children) {
-          const text = writtenText(child);
-          if (text !== null && !kbdKeys().has(text)) {
-            context.report({ node: child, messageId: "hand-written-key" });
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/literal-text.js

@@ -1,41 +0,0 @@
-import { staticAttribute } from "./rendered-import.js";
-
-/** The string a Literal or a template without expressions states, else null. */
-export function literalText(node) {
-  if (!node) return null;
-  if (node.type === "Literal") {
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-    return typeof node.value === "string" ? node.value : null;
-  }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-/** The text a JSX element's children state when all of them are literal text, else null. */
-export function childText(element) {
-  let text = "";
-  for (const child of element.children) {
-    if (child.type === "JSXText") text += child.value;
-    else if (child.type === "JSXExpressionContainer" && literalText(child.expression) !== null) {
-      text += literalText(child.expression);
-    } else return null;
-  }
-  const trimmed = text.replace(/\s+/g, " ").trim();
-  return trimmed === "" ? null : trimmed;
-}
-
-/** The key an object property names, else null. */
-export function keyName(property) {
-  if (property.type !== "Property" || property.computed) return null;
-  if (property.key.type === "Identifier") return property.key.name;
-  return literalText(property.key);
-}
-
-/** An attribute's value when the source states it as a string, else null. */
-export function stringAttribute(openingElement, name) {
-  const value = staticAttribute(openingElement, name);
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- staticAttribute returns true, a number or a string; only typeof picks the string.
-  return typeof value === "string" ? value : null;
-}

package/dist/eslint/rules/menu-owner.js

@@ -1,75 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` holds the menu modules
- * and the ellipsis icons (`repo/menu-owner-imports` in the root config's
- * product-composition blocks), but not a destructive `Button` rendered once per
- * row: that is an import binding joined to where its element renders, which no
- * import rule sees and a selector cannot follow through a renamed import.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const BUTTON = new Map([
-  [
-    "Button",
-    ["@nadicodeai/ui/components/button", PACKAGE_BARREL].map((from) => ({ from, part: "Button" })),
-  ],
-]);
-
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-const ROW_CALLBACKS = new Set(["map", "flatMap"]);
-const ROW_RENDERERS = new Set(["cell", "command"]);
-const ROW_COMPONENT = /Row$/;
-
-const nameOf = (key) => (key?.type === "Identifier" ? key.name : key?.value);
-
-function drawsOneRecord(fn) {
-  const { parent } = fn;
-  if (
-    parent.type === "CallExpression" &&
-    parent.arguments[0] === fn &&
-    parent.callee.type === "MemberExpression" &&
-    !parent.callee.computed &&
-    ROW_CALLBACKS.has(parent.callee.property.name)
-  ) {
-    return true;
-  }
-  if (parent.type === "Property" && parent.value === fn) {
-    return ROW_RENDERERS.has(nameOf(parent.key));
-  }
-  if (parent.type === "JSXExpressionContainer" && parent.parent.type === "JSXAttribute") {
-    return ROW_RENDERERS.has(parent.parent.name.name);
-  }
-  if (fn.type === "FunctionDeclaration") return ROW_COMPONENT.test(fn.id?.name ?? "");
-  return parent.type === "VariableDeclarator" && ROW_COMPONENT.test(nameOf(parent.id) ?? "");
-}
-
-function insideARow(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (FUNCTIONS.has(current.type) && drawsOneRecord(current)) return true;
-  }
-  return false;
-}
-
-export const menuOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A record's destructive command is the last item of its ActionMenu, never a destructive button in its row.",
-    },
-    schema: [],
-    messages: {
-      "row-destructive-button":
-        "A destructive command is the last item of the row's ActionMenu, after a divider.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXOpeningElement(node) {
-        if (partOf(importOf(node.name), BUTTON, context.filename) !== "Button") return;
-        if (staticAttribute(node, "variant") !== "destructive") return;
-        if (insideARow(node)) context.report({ node, messageId: "row-destructive-button" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/middle-truncate-placement.js

@@ -1,69 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector can
- * match `MiddleTruncate` under an element by name, but not that the name is the
- * design system's import, that the class sits in a `cn(...)` call or a
- * same-file table, nor that the nearest control carries an `aria-label`
- * without a second selector per spelling.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-import { renderedImports } from "./rendered-import.js";
-
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-const CONTROLS = new Set(["Button", "ButtonLink", "TextLink"]);
-const HOST_CONTROLS = new Set(["a", "button"]);
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-const TRUNCATING = /^(truncate|text-ellipsis|overflow-ellipsis|line-clamp-(?!none$).+)$/;
-
-const withoutVariants = (utility) => utility.split(":").pop().replace(/^!/, "");
-
-const namesItself = (openingElement) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && NAMING_ATTRIBUTES.has(attribute.name.name),
-  );
-
-export const middleTruncatePlacement = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "MiddleTruncate cuts its own ellipsis and a control around it carries the name.",
-    },
-    schema: [],
-    messages: {
-      "cuts-its-own-ellipsis":
-        "MiddleTruncate cuts its own ellipsis: take it out of the element that also truncates. Inside a control, give the control an aria-label that names its target, since the cut value is not a name.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const designSystemExport = (elementName) => {
-      const imported = importOf(elementName);
-      return imported && FROM_DESIGN_SYSTEM.test(imported.source) ? imported.name : null;
-    };
-    const isControl = ({ name }) =>
-      CONTROLS.has(designSystemExport(name)) ||
-      (name.type === "JSXIdentifier" && HOST_CONTROLS.has(name.name) && !importOf(name));
-    const truncates = (openingElement) =>
-      openingElementClassUtilities(openingElement, context).some((utility) =>
-        TRUNCATING.test(withoutVariants(utility)),
-      );
-
-    return {
-      JSXElement(node) {
-        if (designSystemExport(node.openingElement.name) !== "MiddleTruncate") return;
-        let nearestControl = null;
-        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-          if (ancestor.type !== "JSXElement") continue;
-          const { openingElement } = ancestor;
-          if (truncates(openingElement)) {
-            context.report({ node: node.openingElement, messageId: "cuts-its-own-ellipsis" });
-            return;
-          }
-          if (!nearestControl && isControl(openingElement)) nearestControl = openingElement;
-        }
-        if (nearestControl && !namesItself(nearestControl)) {
-          context.report({ node: node.openingElement, messageId: "cuts-its-own-ellipsis" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-app-feature-component.js

@@ -1,100 +0,0 @@
-/*
- * `@nadicodeai/ui` ships standard components. An operator login, a portal
- * activation screen, a customer-credential panel — those are use cases, and a
- * use case in the package is a screen two consumers can never both want. The
- * boundary is named in the app's vocabulary, so the rule reads names: the
- * module's own file name and everything it exports.
- *
- * Standard tool checked first: core `no-restricted-syntax` matches
- * an exported identifier against a regex through esquery, but it is given one
- * node at a time and never the file that node is in — and a module called
- * `activation.tsx` exporting `Banner` is the case the file name is there to
- * catch. `context.filename` is why this is a rule rather than a selector list.
- *
- * The vocabulary itself is configuration, not code: the banned words live in the
- * workspace's eslint config where the package boundary is drawn, and this file
- * holds only the matching. Replaces the @nadicodeai/ui no-app-feature-components
- * scanner (#822), which built a TypeScript AST over the package's components to
- * ask the same question.
- */
-
-/** `OperatorLoginCard` and `operator-login.tsx` both normalise to `operator-login`. */
-function normalizeName(value) {
-  return value
-    .replace(/\.[jt]sx?$/, "")
-    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-    .replace(/[\s_]+/g, "-")
-    .toLowerCase();
-}
-
-/** The declared names one `export` statement introduces. */
-function exportedNames(node) {
-  if (!node.declaration) {
-    return node.specifiers.map((specifier) => specifier.exported.name ?? specifier.exported.value);
-  }
-  const declaration = node.declaration;
-  if (declaration.type === "VariableDeclaration") {
-    return declaration.declarations
-      .filter((declarator) => declarator.id.type === "Identifier")
-      .map((declarator) => declarator.id.name);
-  }
-  return declaration.id ? [declaration.id.name] : [];
-}
-
-export const noAppFeatureComponent = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow app-owned feature and use-case names in a shared component package",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          names: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: { feature: { type: "string" }, pattern: { type: "string" } },
-              required: ["feature", "pattern"],
-              additionalProperties: false,
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      appFeature:
-        "{{what}} names the {{feature}} use case. This package ships standard components; compose an app feature inside the consuming app.",
-    },
-  },
-  create(context) {
-    const names = (context.options?.[0]?.names ?? []).map(({ feature, pattern }) => ({
-      feature,
-      pattern: new RegExp(pattern),
-    }));
-    if (names.length === 0) return {};
-
-    const feature = (candidate) =>
-      names.find(({ pattern }) => pattern.test(normalizeName(candidate)))?.feature;
-
-    const report = (node, candidate, what) => {
-      const matched = feature(candidate);
-      if (matched)
-        context.report({ node, messageId: "appFeature", data: { what, feature: matched } });
-    };
-
-    return {
-      Program(node) {
-        const file = context.filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
-        report(node, file, `The module name "${file}"`);
-      },
-      ExportNamedDeclaration(node) {
-        for (const name of exportedNames(node)) {
-          report(node, name, `The export "${name}"`);
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-bare-button-label.js

@@ -1,55 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` can match a `Button`
- * whose text is "OK", but not whether that `Button` is the package's (an
- * import binding, so a renamed or local one is judged correctly), nor read the
- * same word off a form's `submit={{ label }}`.
- */
-import { keyName, childText, literalText } from "./literal-text.js";
-import { renderedImports } from "./rendered-import.js";
-
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const BARE = /^(?:submit|ok|okay|confirm)[.!…]*$/i;
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-
-export const noBareButtonLabel = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A button says its result as a verb and a noun, never a bare Submit, OK or Confirm.",
-    },
-    schema: [],
-    messages: {
-      "bare-label":
-        'A button says its result: "Create customer", "Save changes", "Remove mailbox". "{{label}}" says nothing about what happens.',
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-
-    function report(node, label) {
-      context.report({ node, messageId: "bare-label", data: { label } });
-    }
-
-    return {
-      JSXElement(node) {
-        const imported = importOf(node.openingElement.name);
-        if (!imported || !BUTTONS.has(imported.name) || !FROM_DESIGN_SYSTEM.test(imported.source)) {
-          return;
-        }
-        const label = childText(node);
-        if (label !== null && BARE.test(label)) report(node.openingElement, label);
-      },
-      JSXAttribute(node) {
-        if (node.name.name !== "submit" || node.value?.type !== "JSXExpressionContainer") return;
-        const { expression } = node.value;
-        if (expression.type !== "ObjectExpression") return;
-        for (const property of expression.properties) {
-          if (keyName(property) !== "label") continue;
-          const label = literalText(property.value);
-          if (label !== null && BARE.test(label.trim())) report(property.value, label.trim());
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-choice-control-wrapper.js

@@ -1,97 +0,0 @@
-const CHOICE_CONTROLS = new Set(["Select", "ToggleGroup", "RadioGroup", "Tabs"]);
-
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-function enclosingFunction(node) {
-  let current = node.parent;
-  while (current && !FUNCTIONS.has(current.type)) current = current.parent;
-  return current;
-}
-
-/** A component's own props: a destructured or typed parameter. */
-const isComponent = (fn) =>
-  fn.params.some((param) => param.type === "ObjectPattern" || param.typeAnnotation);
-
-/** Whether `owner` handed the element its value: the element's own component, or a callback inside it. */
-function handedTo(element, owner) {
-  for (let fn = enclosingFunction(element); fn; fn = enclosingFunction(fn)) {
-    if (fn === owner) return true;
-    if (isComponent(fn)) return false;
-  }
-  return false;
-}
-
-/** The identifiers in a handler that invoke what they name: the handler itself, a callee, or a method's receiver. */
-function invoked(handler) {
-  const found = [];
-  const visit = (node) => {
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-    if (!node || typeof node.type !== "string") return;
-    if (node.type === "Identifier") {
-      const parent = node.parent;
-      const isCallee = parent?.type === "CallExpression" && parent.callee === node;
-      const isReceiver =
-        parent?.type === "MemberExpression" &&
-        parent.object === node &&
-        parent.parent?.type === "CallExpression" &&
-        parent.parent.callee === parent;
-      if (node === handler || isCallee || isReceiver) found.push(node);
-    }
-    for (const [key, value] of Object.entries(node)) {
-      if (key === "parent") continue;
-      for (const child of Array.isArray(value) ? value : [value]) {
-        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-        if (child && typeof child.type === "string") visit(child);
-      }
-    }
-  };
-  visit(handler);
-  return found;
-}
-
-/**
- * A kit choice control whose onValueChange forwards to a callback the enclosing
- * component was handed. `ToolbarToggle` flattened Base UI's array into a string
- * there, and "Split by" stopped working while every check stayed green.
- */
-export const noChoiceControlWrapper = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Render a kit choice control where its value is used, never behind a wrapper that forwards it.",
-    },
-    schema: [],
-    messages: {
-      wrapper:
-        "Render the kit's {{control}} where the value is used, with its own API: this one forwards onValueChange to \"{{name}}\", which the component was handed, and a wrapper is where the value's shape gets lost.",
-    },
-  },
-  create(context) {
-    return {
-      "JSXAttribute[name.name='onValueChange'] > JSXExpressionContainer"(container) {
-        const opening = container.parent.parent;
-        const control = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-        if (!CHOICE_CONTROLS.has(control)) return;
-        const handler = container.expression;
-        for (const identifier of invoked(handler)) {
-          const scope = context.sourceCode.getScope(identifier);
-          let variable = null;
-          for (let current = scope; current && !variable; current = current.upper) {
-            variable = current.set.get(identifier.name) ?? null;
-          }
-          const definition = variable?.defs[0];
-          if (definition?.type !== "Parameter") continue;
-          if (definition.node === handler) continue;
-          if (!handedTo(opening, definition.node)) continue;
-          context.report({
-            node: container,
-            messageId: "wrapper",
-            data: { control, name: identifier.name },
-          });
-          return;
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-comment.js

@@ -1,77 +0,0 @@
-/*
- * Code says what it does in its names and its structure, and a test says what
- * it proves in its name and its assertions; a comment restates one of them and
- * nothing keeps it true when the code changes. A directive to a tool is not
- * prose for the reader: ESLint's, Oxlint's, TypeScript's, Biome's, Prettier's,
- * coverage's and Vitest's stay, and so does the marker the seam guard requires.
- */
-
-const DIRECTIVE =
-  /^[*/]?\s*(?:@ts-|eslint-|eslint\s+[\w@/-]+\s*:|oxlint-|biome-ignore|<reference\b|istanbul\b|c8\s|prettier-ignore|@vitest-environment|@jsx)/;
-
-const SEAM_MARKER = /^\s*NADIA\((?:added|changed|removed)\):/;
-
-function moduleHeader(comments, firstTokenStart) {
-  const [first, ...rest] = comments;
-  if (first === undefined || first.range[1] > firstTokenStart) return [];
-  if (first.type === "Block") return [first];
-  const run = [first];
-  for (const next of rest) {
-    if (
-      next.type !== "Line" ||
-      next.range[1] > firstTokenStart ||
-      next.loc.start.line !== run.at(-1).loc.end.line + 1
-    ) {
-      break;
-    }
-    run.push(next);
-  }
-  return run;
-}
-
-export const noComment = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow comments in code, but for directives to a tool, the marker the seam guard requires and, when allowed, the one comment that opens a module",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: { allowModuleHeader: { type: "boolean" } },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ allowModuleHeader: false }],
-    messages: {
-      comment:
-        "Code says what it does in its names and its structure, never in a comment. Rename or restructure, or remove the comment.",
-    },
-  },
-
-  create(context) {
-    const [{ allowModuleHeader }] = context.options;
-    const { sourceCode } = context;
-    return {
-      Program() {
-        const prose = sourceCode
-          .getAllComments()
-          .filter(
-            (comment) =>
-              comment.type !== "Shebang" &&
-              !DIRECTIVE.test(comment.value) &&
-              !SEAM_MARKER.test(comment.value),
-          );
-        const header = allowModuleHeader
-          ? moduleHeader(prose, sourceCode.ast.tokens[0]?.range[0] ?? Infinity)
-          : [];
-        for (const comment of prose) {
-          if (!header.includes(comment)) {
-            context.report({ loc: comment.loc, messageId: "comment" });
-          }
-        }
-      },
-    };
-  },
-};