@epilot/zenith-react 0.2.0-next.3 → 0.2.0-next.5

package/codemods/migrate/lib/imports.ts

@@ -0,0 +1,399 @@
+/**
+ * Import bookkeeping: resolve what a file imports from a module, rename a local binding
+ * throughout the file, and rebuild the legacy import as a Zenith import plus whatever stays.
+ */
+import type {
+  ASTPath,
+  Collection,
+  Identifier,
+  ImportDeclaration,
+  ImportSpecifier,
+  JSCodeshift,
+} from "jscodeshift"
+
+export type ImportedName = {
+  imported: string
+  local: string
+  /** `import type { X }` or `import { type X }`. */
+  typeOnly: boolean
+  specifier: ImportSpecifier
+  declaration: ASTPath<ImportDeclaration>
+}
+
+/** Every named import from `moduleSpecifier`, aliases resolved. */
+export function importedNames(
+  j: JSCodeshift,
+  root: Collection,
+  moduleSpecifier: string
+): ImportedName[] {
+  const names: ImportedName[] = []
+  root
+    .find(j.ImportDeclaration, { source: { value: moduleSpecifier } })
+    .forEach((declaration) => {
+      const declarationTypeOnly = declaration.node.importKind === "type"
+      for (const s of declaration.node.specifiers ?? []) {
+        if (s.type !== "ImportSpecifier") continue
+        names.push({
+          imported: String(s.imported.name),
+          local: String(s.local?.name ?? s.imported.name),
+          typeOnly:
+            declarationTypeOnly ||
+            (s as { importKind?: string }).importKind === "type",
+          specifier: s,
+          declaration,
+        })
+      }
+    })
+  return names
+}
+
+/** Imported name → local binding. */
+export function localNames(names: ImportedName[]): Record<string, string> {
+  const map: Record<string, string> = {}
+  for (const n of names) map[n.imported] = n.local
+  return map
+}
+
+/** Whether `name` is bound anywhere at the top level of the file (import, declaration). */
+export function isTopLevelBound(
+  j: JSCodeshift,
+  root: Collection,
+  name: string
+): boolean {
+  const program = root.find(j.Program).paths()[0]
+  if (!program) return false
+  const scope = program.scope
+  if (scope.declares(name)) return true
+  // Imports are bindings too; ast-types' scope tracks them, but be explicit for type-only ones.
+  return (
+    root
+      .find(j.ImportSpecifier)
+      .filter(
+        (p) => String(p.node.local?.name ?? p.node.imported.name) === name
+      )
+      .size() > 0
+  )
+}
+
+/** Every reference path to the local binding `name`: identifiers and JSX tags. */
+function referencePaths(
+  j: JSCodeshift,
+  root: Collection,
+  name: string
+): ASTPath[] {
+  const paths: ASTPath[] = []
+  root.find(j.JSXIdentifier, { name }).forEach((p) => {
+    const parent = p.parent.node
+    if (parent.type === "JSXAttribute") return
+    if (parent.type === "JSXMemberExpression" && parent.property === p.node)
+      return
+    paths.push(p as ASTPath)
+  })
+  valueUses(j, root, name).forEach((p) => paths.push(p as ASTPath))
+  return paths
+}
+
+/**
+ * Whether any reference to `from` sits in a scope where `name` is bound (a prop, a parameter, a
+ * local): renaming `from` to `name` there would capture that binding instead of the import.
+ */
+export function referenceSeesBinding(
+  j: JSCodeshift,
+  root: Collection,
+  from: string,
+  name: string
+): boolean {
+  return referencePaths(j, root, from).some((p) => {
+    const scope = (p as { scope?: { lookup(n: string): unknown } }).scope
+    return !!scope?.lookup(name)
+  })
+}
+
+/** Whether `name` is bound in any scope of the file (top level, a function, a catch clause). */
+export function isBoundAnywhere(
+  j: JSCodeshift,
+  root: Collection,
+  name: string
+): boolean {
+  if (isTopLevelBound(j, root, name)) return true
+  const scopes = [
+    ...root.find(j.Function).paths(),
+    ...root.find(j.CatchClause).paths(),
+  ] as { scope?: { declares(n: string): boolean } }[]
+  return scopes.some((p) => !!p.scope?.declares(name))
+}
+
+/**
+ * Renames every reference to the local binding `from` to `to`: JSX tags, identifiers, type
+ * references, `typeof` queries. Property keys, member-expression properties and JSX attribute
+ * names are not references and stay as they are. Import specifiers are rebuilt by the caller.
+ */
+export function renameBinding(
+  j: JSCodeshift,
+  root: Collection,
+  from: string,
+  to: string
+): void {
+  if (from === to) return
+  root.find(j.JSXIdentifier, { name: from }).forEach((path) => {
+    const parent = path.parent.node
+    if (parent.type === "JSXAttribute") return
+    if (parent.type === "JSXMemberExpression" && parent.property === path.node)
+      return
+    path.node.name = to
+  })
+  root.find(j.Identifier, { name: from }).forEach((path) => {
+    const parent = path.parent.node
+    const node = path.node
+    switch (parent.type) {
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+      case "ExportSpecifier":
+        return
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        if (parent.property === node && !parent.computed) return
+        break
+      case "Property":
+      case "ObjectProperty": {
+        if (parent.key === node && !parent.computed) {
+          if (parent.shorthand && parent.value === node) {
+            // `{ Spinner }` is a reference to the binding AND a key: keep the key, rename the value.
+            parent.shorthand = false
+            parent.value = j.identifier(to)
+          }
+          return
+        }
+        break
+      }
+      case "MethodDefinition":
+      case "ClassMethod":
+      case "ClassProperty":
+      case "TSPropertySignature":
+      case "TSMethodSignature":
+      case "ObjectMethod":
+        if (parent.key === node && !parent.computed) return
+        break
+      case "LabeledStatement":
+      case "BreakStatement":
+      case "ContinueStatement":
+        return
+      default:
+        break
+    }
+    node.name = to
+  })
+}
+
+/**
+ * References to the local binding `name` as a value, outside JSX tags and import specifiers:
+ * property keys, member-expression properties and type positions are not references.
+ */
+export function valueUses(
+  j: JSCodeshift,
+  root: Collection,
+  name: string
+): Collection<Identifier> {
+  return root.find(j.Identifier, { name }).filter((path) => {
+    const parent = path.parent.node
+    const node = path.node
+    // ast-types derives JSXIdentifier from Identifier: tags and attribute names are not values.
+    if (node.type !== "Identifier") return false
+    switch (parent.type) {
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+      case "TSTypeReference":
+      case "TSTypeQuery":
+      case "TSQualifiedName":
+      case "TSExpressionWithTypeArguments":
+      case "LabeledStatement":
+      case "BreakStatement":
+      case "ContinueStatement":
+        return false
+      case "ExportSpecifier":
+        return parent.local === node
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        return !(parent.property === node && !parent.computed)
+      case "Property":
+      case "ObjectProperty":
+        if (parent.key === node && !parent.computed) return !!parent.shorthand
+        return true
+      case "MethodDefinition":
+      case "ClassMethod":
+      case "ClassProperty":
+      case "TSPropertySignature":
+      case "TSMethodSignature":
+      case "ObjectMethod":
+        return !(parent.key === node && !parent.computed)
+      default:
+        return true
+    }
+  })
+}
+
+export type Moved = {
+  imported: string
+  local: string
+  typeOnly: boolean
+}
+
+/**
+ * Adds `moved` to the file's import of `zenith` (any module: Zenith, or an upstream library),
+ * merging into the first existing one (or creating one `before` the given declaration). Type-only names go to an `import type` declaration when the
+ * value import does not exist yet; otherwise they are inline `type` specifiers.
+ */
+export function addToZenithImport(
+  j: JSCodeshift,
+  root: Collection,
+  zenith: string,
+  moved: Moved[],
+  before: ASTPath<ImportDeclaration>,
+  quote: "single" | "double"
+): ImportDeclaration[] {
+  // Two legacy names moved onto the same Zenith binding are one specifier.
+  const seen = new Set<string>()
+  moved = moved.filter((m) => {
+    const key = `${m.imported}\0${m.local}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+  if (moved.length === 0) return []
+  const existing = root
+    .find(j.ImportDeclaration, { source: { value: zenith } })
+    .filter((p) => p.node.importKind !== "type")
+    .paths()[0]
+  const existingType = root
+    .find(j.ImportDeclaration, { source: { value: zenith } })
+    .filter((p) => p.node.importKind === "type")
+    .paths()[0]
+
+  const q = quote === "single" ? "'" : '"'
+  const moduleLiteral = () => {
+    const node = j.literal(zenith) as { extra?: unknown }
+    node.extra = { raw: `${q}${zenith}${q}`, rawValue: zenith }
+    return node as ReturnType<typeof j.literal>
+  }
+  const specifier = (m: Moved, inlineType: boolean) => {
+    const s = j.importSpecifier(
+      j.identifier(m.imported),
+      m.local === m.imported ? null : j.identifier(m.local)
+    )
+    if (inlineType) (s as { importKind?: string }).importKind = "type"
+    return s
+  }
+  const has = (decl: ImportDeclaration, m: Moved) =>
+    (decl.specifiers ?? []).some(
+      (s) =>
+        s.type === "ImportSpecifier" &&
+        String(s.imported.name) === m.imported &&
+        String(s.local?.name ?? s.imported.name) === m.local
+    )
+
+  const values = moved.filter((m) => !m.typeOnly)
+  const types = moved.filter((m) => m.typeOnly)
+
+  const insertAfter: ImportDeclaration[] = []
+  if (existing) {
+    for (const m of values)
+      if (!has(existing.node, m))
+        existing.node.specifiers!.push(specifier(m, false))
+    for (const m of types)
+      if (
+        !has(existing.node, m) &&
+        !(existingType && has(existingType.node, m))
+      )
+        existing.node.specifiers!.push(specifier(m, true))
+  } else {
+    if (values.length) {
+      const decl = j.importDeclaration(
+        values.map((m) => specifier(m, false)),
+        moduleLiteral()
+      )
+      insertAfter.push(decl)
+    }
+    if (types.length) {
+      if (existingType) {
+        for (const m of types)
+          if (!has(existingType.node, m))
+            existingType.node.specifiers!.push(specifier(m, false))
+      } else if (values.length) {
+        for (const m of types)
+          insertAfter[0].specifiers!.push(specifier(m, true))
+      } else {
+        const decl = j.importDeclaration(
+          types.map((m) => specifier(m, false)),
+          moduleLiteral()
+        )
+        decl.importKind = "type"
+        insertAfter.push(decl)
+      }
+    }
+  }
+  for (const decl of insertAfter) before.insertBefore(decl)
+  return insertAfter
+}
+
+type CommentLike = {
+  type?: string
+  value?: string
+  leading?: boolean
+  trailing?: boolean
+  loc?: unknown
+}
+
+/**
+ * Moves `comments` (the leading ones) from `from` to the front of `to`. A file-leading
+ * `/* eslint-disable *\/` above the first import belongs to the file: when that import gets a
+ * new import inserted above it, or goes away, the comment moves to the Program node, which recast
+ * prints at the top with no extra blank line (on the inserted import it would get one).
+ */
+export function hoistLeadingComments(
+  from: { comments?: CommentLike[] | null },
+  to: { comments?: CommentLike[] | null },
+  comments: CommentLike[] = from.comments ?? []
+): void {
+  const leading = comments.filter((c) => c.leading !== false)
+  if (leading.length === 0) return
+  from.comments = (from.comments ?? []).filter((c) => !leading.includes(c))
+  if (from.comments.length === 0) from.comments = null
+  // Copies without source positions: recast would otherwise keep the moved comment's original
+  // whitespace and print a blank line where it used to be.
+  const copies = leading.map((c) => ({
+    type: c.type,
+    value: c.value,
+    leading: true,
+    trailing: false,
+  }))
+  to.comments = [...copies, ...(to.comments ?? [])]
+}
+
+/**
+ * Where a first statement's leading comments go when something is inserted above it: the
+ * Program node (printed at the top), unless the file opens with a directive such as
+ * `"use client"`, which must stay first; then `undefined`, and the caller puts the comments on
+ * the inserted statement. Undefined as well when `path` is not the first statement.
+ */
+export function programIfFirstStatement(
+  path: ASTPath
+): { comments?: CommentLike[] | null } | undefined {
+  const parent = path.parent?.node as
+    { type?: string; body?: unknown[]; directives?: unknown[] } | undefined
+  if (parent?.type !== "Program") return undefined
+  if (parent.body?.[0] !== path.node) return undefined
+  return parent.directives?.length ? undefined : (parent as never)
+}
+
+/** Whether `path` is the first statement of a Program that opens with a directive. */
+export function isFirstStatementAfterDirective(path: ASTPath): boolean {
+  const parent = path.parent?.node as
+    { type?: string; body?: unknown[]; directives?: unknown[] } | undefined
+  return (
+    parent?.type === "Program" &&
+    parent.body?.[0] === path.node &&
+    !!parent.directives?.length
+  )
+}

package/codemods/migrate/lib/jsx.ts

@@ -0,0 +1,313 @@
+/**
+ * JSX helpers for rule modules: read, rename, drop and map props; wrap children in a part; rename
+ * a tag; merge into an inline `style`. Every helper is a local, syntactic edit on one element.
+ */
+import type {
+  ASTPath,
+  ConditionalExpression,
+  JSCodeshift,
+  JSXAttribute,
+  JSXElement,
+  JSXSpreadAttribute,
+  ObjectExpression,
+} from "jscodeshift"
+
+export type Literal = string | number | boolean
+
+export type JsxHelpers = ReturnType<typeof makeJsxHelpers>
+
+type Attr = JSXAttribute | JSXSpreadAttribute
+
+export function makeJsxHelpers(j: JSCodeshift) {
+  const attrsOf = (el: JSXElement): JSXAttribute[] =>
+    (el.openingElement.attributes ?? []).filter(
+      (a): a is JSXAttribute => a.type === "JSXAttribute"
+    )
+  const attrName = (a: JSXAttribute) =>
+    a.name.type === "JSXIdentifier"
+      ? a.name.name
+      : `${a.name.namespace.name}:${a.name.name.name}`
+  const attr = (el: JSXElement, name: string) =>
+    attrsOf(el).find((a) => attrName(a) === name)
+  const setAttrs = (el: JSXElement, attrs: Attr[]) => {
+    el.openingElement.attributes = attrs
+  }
+
+  /** The literal value of an attribute, when it has one. `<X flag />` is `true`. */
+  const literal = (a: JSXAttribute | undefined): Literal | undefined => {
+    if (!a) return undefined
+    const v = a.value
+    if (v == null) return true
+    if (v.type === "StringLiteral" || v.type === "Literal") {
+      return typeof v.value === "string" ? v.value : undefined
+    }
+    if (v.type === "JSXExpressionContainer") {
+      const e = v.expression
+      if (e.type === "StringLiteral") return e.value
+      if (e.type === "NumericLiteral") return e.value
+      if (e.type === "BooleanLiteral") return e.value
+      if (e.type === "Literal") {
+        const lv = (e as { value: unknown }).value
+        if (
+          typeof lv === "string" ||
+          typeof lv === "number" ||
+          typeof lv === "boolean"
+        )
+          return lv
+      }
+      if (e.type === "TemplateLiteral" && e.expressions.length === 0) {
+        return e.quasis[0]?.value.cooked ?? undefined
+      }
+    }
+    return undefined
+  }
+
+  /**
+   * A string literal that prints with the given quote whatever `toSource` options say: recast
+   * honours `extra.raw` on an ESTree `Literal`. JSX attributes are conventionally double-quoted.
+   */
+  const str = (value: string, quote: '"' | "'" = '"') => {
+    const node = j.literal(value) as { extra?: unknown }
+    node.extra = { raw: `${quote}${value}${quote}`, rawValue: value }
+    return node as ReturnType<typeof j.literal>
+  }
+
+  const valueNode = (value: Literal | null | ASTPath["node"]) => {
+    if (value === null) return null
+    if (typeof value === "string") return str(value)
+    if (typeof value === "number")
+      return j.jsxExpressionContainer(j.numericLiteral(value))
+    if (typeof value === "boolean")
+      return j.jsxExpressionContainer(j.booleanLiteral(value))
+    return j.jsxExpressionContainer(value as never)
+  }
+
+  type Expr = ConditionalExpression["consequent"]
+  const branchQuote = (node: { extra?: { raw?: string } }): '"' | "'" =>
+    node.extra?.raw?.startsWith("'") ? "'" : '"'
+  /** A branch: a string literal through the map (`null` → `undefined`), or a nested ternary. */
+  const mapBranch = (
+    node: Expr,
+    map: Record<string, string | null>
+  ): Expr | "dynamic" | "unknown" => {
+    if (node.type === "ConditionalExpression") return mapConditional(node, map)
+    const value =
+      node.type === "StringLiteral"
+        ? node.value
+        : node.type === "Literal" && typeof node.value === "string"
+          ? node.value
+          : undefined
+    if (value === undefined) return "dynamic"
+    if (!(value in map)) return "unknown"
+    const target = map[value]
+    if (target === null) return j.identifier("undefined")
+    return str(target, branchQuote(node as never)) as Expr
+  }
+  const mapConditional = (
+    node: ConditionalExpression,
+    map: Record<string, string | null>
+  ): ConditionalExpression | "dynamic" | "unknown" => {
+    const consequent = mapBranch(node.consequent, map)
+    if (consequent === "dynamic" || consequent === "unknown") return consequent
+    const alternate = mapBranch(node.alternate, map)
+    if (alternate === "dynamic" || alternate === "unknown") return alternate
+    return j.conditionalExpression(node.test, consequent, alternate)
+  }
+
+  const helpers = {
+    attrs: attrsOf,
+    attr,
+    attrName,
+    literal,
+    str,
+    /** The tag name of an element when it is a plain identifier (`<Button>`, not `<Ui.Button>`). */
+    tagName(el: JSXElement): string | undefined {
+      const n = el.openingElement.name
+      return n.type === "JSXIdentifier" ? n.name : undefined
+    },
+    hasSpread(el: JSXElement): boolean {
+      return (el.openingElement.attributes ?? []).some(
+        (a) => a.type === "JSXSpreadAttribute"
+      )
+    },
+    /** Removes the attribute and returns it, or `undefined` when absent. */
+    removeAttr(el: JSXElement, name: string): JSXAttribute | undefined {
+      const found = attr(el, name)
+      if (!found) return undefined
+      setAttrs(
+        el,
+        (el.openingElement.attributes ?? []).filter((a) => a !== found)
+      )
+      return found
+    },
+    renameAttr(el: JSXElement, from: string, to: string): boolean {
+      const found = attr(el, from)
+      if (!found) return false
+      found.name = j.jsxIdentifier(to)
+      return true
+    },
+    /**
+     * Sets (or replaces) an attribute. A string becomes `name="…"`, a number or boolean an
+     * expression, `null` a bare boolean attribute, and any other node an expression container.
+     */
+    setAttr(
+      el: JSXElement,
+      name: string,
+      value: Literal | null | ASTPath["node"]
+    ): void {
+      const next = j.jsxAttribute(j.jsxIdentifier(name), valueNode(value))
+      const existing = attr(el, name)
+      if (existing) {
+        setAttrs(
+          el,
+          (el.openingElement.attributes ?? []).map((a) =>
+            a === existing ? next : a
+          )
+        )
+      } else {
+        setAttrs(el, [...(el.openingElement.attributes ?? []), next])
+      }
+    },
+    /**
+     * Maps a string-literal attribute through `map` (`null` drops the attribute), or a ternary
+     * whose branches are all literals in the map (nested ternaries too; `null` becomes
+     * `undefined` there). Returns
+     * `absent` when the element has no such attribute, `dynamic` when its value is not a literal,
+     * `unknown` when the literal is not in the map (the attribute is left as it was), and `mapped`.
+     */
+    mapAttrValue(
+      el: JSXElement,
+      name: string,
+      map: Record<string, string | null>
+    ): "mapped" | "dynamic" | "absent" | "unknown" {
+      const found = attr(el, name)
+      if (!found) return "absent"
+      const value = literal(found)
+      if (typeof value === "string") {
+        if (!(value in map)) return "unknown"
+        const target = map[value]
+        if (target === null) helpers.removeAttr(el, name)
+        else found.value = str(target)
+        return "mapped"
+      }
+      // `cond ? "a" : "b"` (nested too): every branch is a literal in the map, or nothing moves.
+      if (
+        found.value?.type === "JSXExpressionContainer" &&
+        found.value.expression.type === "ConditionalExpression"
+      ) {
+        const mapped = mapConditional(found.value.expression, map)
+        if (mapped === "dynamic" || mapped === "unknown") return mapped
+        found.value = j.jsxExpressionContainer(mapped)
+        return "mapped"
+      }
+      return "dynamic"
+    },
+    /**
+     * An attribute parsed from source text, printed verbatim (recast keeps a parsed node's own
+     * formatting): `parseAttr('style={{ width: 200 }}')` stays on one line where a built
+     * object literal would be reflowed.
+     */
+    parseAttr(text: string): JSXAttribute {
+      const el = j(`<x ${text} />`).find(j.JSXAttribute).paths()[0]
+      if (!el) throw new Error(`parseAttr: no attribute in ${text}`)
+      return el.node
+    },
+    /** Source text of an attribute, for TODO messages (`size={progress}`). */
+    print(a: JSXAttribute): string {
+      return j(a).toSource()
+    },
+    /** `<El>children</El>` → `<El><Part>children</Part></El>`; returns the new part. */
+    wrapChildren(el: JSXElement, partTag: string): JSXElement {
+      const part = j.jsxElement(
+        j.jsxOpeningElement(j.jsxIdentifier(partTag)),
+        j.jsxClosingElement(j.jsxIdentifier(partTag)),
+        el.children ?? []
+      )
+      el.children = [part]
+      return part
+    },
+    /** Replaces `path`'s element with `<Wrapper>…</Wrapper>` around it; returns the wrapper. */
+    wrap(path: ASTPath<JSXElement>, wrapperTag: string): JSXElement {
+      const wrapper = j.jsxElement(
+        j.jsxOpeningElement(j.jsxIdentifier(wrapperTag)),
+        j.jsxClosingElement(j.jsxIdentifier(wrapperTag)),
+        [path.node]
+      )
+      path.replace(wrapper)
+      return wrapper
+    },
+    /** Renames the opening and closing tag. */
+    rename(el: JSXElement, tag: string): void {
+      el.openingElement.name = j.jsxIdentifier(tag)
+      if (el.closingElement) el.closingElement.name = j.jsxIdentifier(tag)
+    },
+    /** Replaces the element's children. */
+    setChildren(el: JSXElement, children: JSXElement["children"]): void {
+      if (!children || children.length === 0) {
+        el.children = []
+        el.openingElement.selfClosing = true
+        el.closingElement = null
+        return
+      }
+      el.children = children
+      el.openingElement.selfClosing = false
+      if (!el.closingElement)
+        el.closingElement = j.jsxClosingElement(el.openingElement.name)
+    },
+    /** A child node for a `label`-style prop value: text for a string, `{expr}` otherwise. */
+    childFromValue(
+      a: JSXAttribute
+    ): NonNullable<JSXElement["children"]>[number] {
+      const value = literal(a)
+      if (typeof value === "string") return j.jsxText(value)
+      if (a.value?.type === "JSXExpressionContainer") {
+        const e = a.value.expression
+        if (e.type === "JSXElement" || e.type === "JSXFragment") return e
+        return j.jsxExpressionContainer(e as never)
+      }
+      return j.jsxExpressionContainer(j.booleanLiteral(true))
+    },
+    /**
+     * The object literal of `style={{…}}`, created when absent. `undefined` when `style` is
+     * present but not an object literal (the caller reports a TODO).
+     */
+    styleObject(el: JSXElement): ObjectExpression | undefined {
+      const existing = attr(el, "style")
+      if (!existing) {
+        const object = j.objectExpression([])
+        helpers.setAttr(el, "style", object)
+        return object
+      }
+      const v = existing.value
+      if (
+        v?.type === "JSXExpressionContainer" &&
+        v.expression.type === "ObjectExpression"
+      )
+        return v.expression
+      return undefined
+    },
+    /** Adds `key: value` to an object literal, replacing an existing non-computed key. */
+    setObjectKey(
+      object: ObjectExpression,
+      key: string,
+      value: ASTPath["node"]
+    ): void {
+      object.properties = object.properties.filter((p) => {
+        if (p.type !== "ObjectProperty" && p.type !== "Property") return true
+        if (p.computed) return true
+        const k = p.key
+        const name =
+          k.type === "Identifier"
+            ? k.name
+            : k.type === "StringLiteral"
+              ? k.value
+              : undefined
+        return name !== key
+      })
+      object.properties.push(
+        j.objectProperty(j.identifier(key), value as never)
+      )
+    },
+  }
+  return helpers
+}