@woodsportal/hubspot-kit 5.0.0-beta.2 → 5.0.0-beta.4

package/CHANGELOG.md

@@ -1,11 +1,5 @@
 # Changelog
 
-## Unreleased
-
-### CSS prefix
-- **Auto-prefix** — class string bindings ending in `_CLASS` (e.g. `CARDS_GRID_CLASS`) are prefixed the same as `*DynamicClassName*`
-- **Auto-prefix** — JSX props ending in `ClassName` (`containerClassName`, `pageLinkClassName`, …) and helpers ending in `Class` (`paginationItemBaseClass`, `navBtnClass`) are prefixed
-
 ## [1.0.44] - 2026-08-06
 
 ### Portal auth scaffold

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@woodsportal/hubspot-kit",
-  "version": "5.0.0-beta.2",
+  "version": "5.0.0-beta.4",
   "packageManager": "pnpm@10.12.1",
   "description": "WoodsCLI — HubSpot CMS dev kit by WoodsPortal. wp CLI, Vite presets, module-config overlay, and theme/module build pipelines.",
   "type": "module",
@@ -52,7 +52,7 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test 'src/lib/**/*.test.ts' 'src/cli/**/*.test.ts' 'src/schema/**/*.test.ts' 'src/vite/**/*.test.ts' 'scripts/portal-build-id.test.mjs' 'scripts/resolve-consumer-dep.test.mjs' 'scripts/wp-cli-smoke.test.mjs' 'scripts/vite/ensure-dev-kit-shims.test.mjs' 'scripts/vite/consumer-react-aliases.test.mjs' 'scripts/vite/resolve-from-project-root.test.mjs' 'scripts/tailwind/prefix-plugin.test.mjs' && vitest run src/dev-module-config/__tests__/normalize-repeater-items.test.ts src/dev-module-config/__tests__/module-config-transform.test.ts src/dev-module-config/__tests__/flatten-visible-fields.test.ts src/dev-module-config/__tests__/drill-down-panels.test.ts",
+    "test": "node --import tsx --test 'src/lib/**/*.test.ts' 'src/cli/**/*.test.ts' 'src/schema/**/*.test.ts' 'src/vite/**/*.test.ts' 'scripts/portal-build-id.test.mjs' 'scripts/resolve-consumer-dep.test.mjs' 'scripts/wp-cli-smoke.test.mjs' 'scripts/vite/ensure-dev-kit-shims.test.mjs' 'scripts/vite/consumer-react-aliases.test.mjs' 'scripts/vite/resolve-from-project-root.test.mjs' && vitest run src/dev-module-config/__tests__/normalize-repeater-items.test.ts src/dev-module-config/__tests__/module-config-transform.test.ts src/dev-module-config/__tests__/flatten-visible-fields.test.ts",
     "test:examples": "node examples/smoke/run-matrix.mjs --tier static",
     "test:dist-pack": "node --test scripts/dist-cli-pack-smoke.test.mjs",
     "lint": "eslint src",

package/scripts/tailwind/prefix-plugin.js

@@ -7,49 +7,15 @@ import { prefix } from './prefix.env.js'
 const prefix1 = `${prefix}:`
 const prefix2 = `${prefix}\:`
 
-/** Bindings rewritten even when not in `className=`: `*DynamicClassName*`, `_CLASS`, `*ClassName`, `*Class`. */
-export function isClassBindingName(name) {
-  if (!name) return false
-  return (
-    name.includes('DynamicClassName') ||
-    name.endsWith('_CLASS') ||
-    /(?:ClassName|Class)$/.test(name)
-  )
-}
-
-/** JSX / object keys: `className`, `containerClassName`, `pageLinkClassName`, … */
-export function isClassAttrName(name) {
-  if (!name) return false
-  return name === 'className' || name.endsWith('ClassName')
-}
-
-function jsxAttrName(attr) {
-  if (t.isJSXIdentifier(attr.name)) return attr.name.name
-  return ''
-}
-
-function objectKeyName(key) {
-  if (t.isIdentifier(key)) return key.name
-  if (t.isStringLiteral(key)) return key.value
-  return ''
-}
-
-/** Vite serve ids often include `?t=` / `?v=` — strip those before extension checks. */
-function filePathFromId(id) {
-  return (id.split('?')[0] ?? id).replaceAll('\\', '/')
-}
-
 export default function TailwindPrefixPlugin() {
   return {
     name: 'vite-tailwind-prefix',
     enforce: 'pre',
     transform(code, id) {
-      const filename = filePathFromId(id)
-
       // Handle CSS files: prefix custom class selectors safely
-      if (filename.endsWith('.css')) {
+      if (id.endsWith('.css')) {
         // don't need to add prefix to override.style.css
-        if (filename.endsWith('override.style.css')) return code;
+        if (id.endsWith('override.style.css')) return code;
 
 
         const lines = code.split('\n')
@@ -95,7 +61,7 @@ export default function TailwindPrefixPlugin() {
       }
 
 
-      if (!filename.endsWith('.tsx') && !filename.endsWith('.ts')) return null
+      if (!id.endsWith('.tsx') && !id.endsWith('.ts')) return null
 
       try {
         const ast = parse(code, {
@@ -129,84 +95,23 @@ export default function TailwindPrefixPlugin() {
             .join(' ')
         }
 
-        const prefixExpr = (expr) => {
-          if (!expr) return expr
-
-          if (
-            t.isTSAsExpression(expr) ||
-            t.isTSTypeAssertion(expr) ||
-            t.isTSSatisfiesExpression(expr) ||
-            t.isTSNonNullExpression(expr) ||
-            t.isParenthesizedExpression(expr)
-          ) {
-            expr.expression = prefixExpr(expr.expression)
-            return expr
-          }
-
+        const prefixStringExpr = (expr) => {
           if (t.isStringLiteral(expr)) {
             return t.stringLiteral(prefixClasses(expr.value))
           }
-
-          if (t.isTemplateLiteral(expr)) {
-            const quasis = expr.quasis.map((quasi, i) => {
-              let classes = prefixClasses(quasi.value.raw)
-              if (i < expr.expressions.length) classes += ' '
-              if (i > 0 && !classes.startsWith(' ')) classes = ' ' + classes
-              return t.templateElement({ raw: classes, cooked: classes })
-            })
-            const expressions = expr.expressions.map((inner) => prefixExpr(inner))
-            return t.templateLiteral(quasis, expressions)
-          }
-
           if (t.isConditionalExpression(expr)) {
-            expr.consequent = prefixExpr(expr.consequent)
-            expr.alternate = prefixExpr(expr.alternate)
-            return expr
-          }
-
-          if (t.isLogicalExpression(expr)) {
-            if (t.isStringLiteral(expr.left) || t.isTemplateLiteral(expr.left)) {
-              expr.left = prefixExpr(expr.left)
-            }
-            expr.right = prefixExpr(expr.right)
-            return expr
-          }
-
-          if (t.isObjectExpression(expr)) {
-            expr.properties.forEach((prop) => {
-              if (!t.isObjectProperty(prop) || prop.computed) return
-              prop.value = prefixExpr(prop.value)
-            })
-            return expr
-          }
-
-          if (t.isArrayExpression(expr)) {
-            expr.elements = expr.elements.map((el) => {
-              if (!el || t.isSpreadElement(el)) return el
-              return prefixExpr(el)
-            })
-            return expr
-          }
-
-          if (t.isCallExpression(expr)) {
-            expr.arguments = expr.arguments.map((arg) => {
-              if (t.isSpreadElement(arg)) return arg
-              return prefixExpr(arg)
-            })
-            return expr
-          }
-
-          if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr)) {
-            if (!t.isBlockStatement(expr.body)) {
-              expr.body = prefixExpr(expr.body)
-            }
-            return expr
+            return t.conditionalExpression(
+              expr.test,
+              prefixStringExpr(expr.consequent),
+              prefixStringExpr(expr.alternate),
+            )
           }
-
           return expr
         }
 
         traverse.default(ast, {
+          // ✅ Handle variables whose name includes "DynamicClassName"
+
           ReturnStatement(path) {
             const fn = path.getFunctionParent()
             if (!fn) return
@@ -222,37 +127,186 @@ export default function TailwindPrefixPlugin() {
                 fnName = parent.id.name
               }
             }
-            if (!isClassBindingName(fnName)) return
-            if (path.node.argument) {
-              path.node.argument = prefixExpr(path.node.argument)
+            const isClassHelper =
+              fnName.includes('DynamicClassName') ||
+              /(?:ClassName|Class)$/.test(fnName)
+            if (!isClassHelper) return
+
+            if (t.isStringLiteral(path.node.argument)) {
+              path.node.argument = t.stringLiteral(prefixClasses(path.node.argument.value))
+            } else if (t.isConditionalExpression(path.node.argument)) {
+              path.node.argument = prefixStringExpr(path.node.argument)
             }
           },
 
           JSXAttribute(path) {
-            if (!isClassAttrName(jsxAttrName(path.node))) return
+            if (path.node.name.name !== 'className') return
+
             const value = path.node.value
+
+            // String literal: className="..."
             if (t.isStringLiteral(value)) {
               path.node.value = t.stringLiteral(prefixClasses(value.value))
-              return
             }
-            if (t.isJSXExpressionContainer(value)) {
-              value.expression = prefixExpr(value.expression)
+            // Template literal: className={`...`}
+            else if (
+              t.isJSXExpressionContainer(value) &&
+              t.isTemplateLiteral(value.expression)
+            ) {
+              const quasis = value.expression.quasis.map((quasi, i) => {
+                let classes = prefixClasses(quasi.value.raw)
+
+                if (i < value.expression.expressions.length) classes += ' '
+                if (i > 0 && !classes.startsWith(' ')) classes = ' ' + classes
+
+                return t.templateElement({ raw: classes, cooked: classes })
+              })
+
+              // 🔥 also fix expressions inside ${ ... }
+              const expressions = value.expression.expressions.map((expr) => {
+                if (t.isStringLiteral(expr)) {
+                  return t.stringLiteral(prefixClasses(expr.value))
+                }
+                if (t.isLogicalExpression(expr)) {
+                  if (t.isStringLiteral(expr.right)) {
+                    return t.logicalExpression(
+                      expr.operator,
+                      expr.left,
+                      t.stringLiteral(prefixClasses(expr.right.value)),
+                    )
+                  }
+                }
+                if (t.isConditionalExpression(expr)) {
+                  const newConsequent = t.isStringLiteral(expr.consequent)
+                    ? t.stringLiteral(prefixClasses(expr.consequent.value))
+                    : expr.consequent
+                  const newAlternate = t.isStringLiteral(expr.alternate)
+                    ? t.stringLiteral(prefixClasses(expr.alternate.value))
+                    : expr.alternate
+                  return t.conditionalExpression(
+                    expr.test,
+                    newConsequent,
+                    newAlternate,
+                  )
+                }
+                return expr
+              })
+
+              path.node.value = t.jsxExpressionContainer(
+                t.templateLiteral(quasis, expressions),
+              )
             }
-          },
 
-          ObjectProperty(path) {
-            if (path.node.computed) return
-            const keyName = objectKeyName(path.node.key)
-            if (!isClassAttrName(keyName) && !isClassBindingName(keyName)) return
-            path.node.value = prefixExpr(path.node.value)
-          },
+            // className={condition ? "..." : "..."}
+            else if (
+              t.isJSXExpressionContainer(value) &&
+              t.isConditionalExpression(value.expression)
+            ) {
+              const expr = value.expression
+              path.node.value = t.jsxExpressionContainer(
+                t.conditionalExpression(
+                  expr.test,
+                  prefixStringExpr(expr.consequent),
+                  prefixStringExpr(expr.alternate),
+                ),
+              )
+            }
 
+            // Other expressions (e.g., clsx())
+            else if (
+              t.isJSXExpressionContainer(value) &&
+              t.isCallExpression(value.expression)
+            ) {
+              const args = value.expression.arguments.map((arg) => {
+                if (t.isStringLiteral(arg))
+                  return t.stringLiteral(prefixClasses(arg.value))
+                return arg
+              })
+              path.node.value = t.jsxExpressionContainer(
+                t.callExpression(value.expression.callee, args),
+              )
+            }
+          },
           VariableDeclarator(path) {
             const id = path.node.id
             const init = path.node.init
-            if (!t.isIdentifier(id) || !init) return
-            if (!isClassBindingName(id.name)) return
-            path.node.init = prefixExpr(init)
+            if (!t.isIdentifier(id)) return
+
+            // 🔹 only affect DynamicClassName variables
+            if (!id.name.includes('DynamicClassName')) return
+            if (!init) return
+
+            const prefixString = (expr) =>
+              t.isStringLiteral(expr)
+                ? t.stringLiteral(prefixClasses(expr.value))
+                : expr
+
+            const prefixObject = (objExpr) => {
+              if (!t.isObjectExpression(objExpr)) return objExpr
+              objExpr.properties.forEach((prop) => {
+                if (t.isObjectProperty(prop)) {
+                  if (t.isStringLiteral(prop.value)) {
+                    prop.value = t.stringLiteral(
+                      prefixClasses(prop.value.value),
+                    )
+                  } else if (t.isTemplateLiteral(prop.value)) {
+                    const quasis = prop.value.quasis.map((quasi) => {
+                      const raw = prefixClasses(quasi.value.raw)
+                      return t.templateElement({ raw, cooked: raw })
+                    })
+                    prop.value = t.templateLiteral(
+                      quasis,
+                      prop.value.expressions,
+                    )
+                  } else if (t.isObjectExpression(prop.value)) {
+                    prop.value = prefixObject(prop.value) // recurse
+                  } else if (t.isConditionalExpression(prop.value)) {
+                    prop.value = t.conditionalExpression(
+                      prop.value.test,
+                      prefixString(prop.value.consequent),
+                      prefixString(prop.value.alternate),
+                    )
+                  } else if (t.isLogicalExpression(prop.value)) {
+                    const right = t.isStringLiteral(prop.value.right)
+                      ? t.stringLiteral(prefixClasses(prop.value.right.value))
+                      : prop.value.right
+                    prop.value = t.logicalExpression(
+                      prop.value.operator,
+                      prop.value.left,
+                      right,
+                    )
+                  }
+                }
+              })
+              return objExpr
+            }
+
+            if (t.isStringLiteral(init)) {
+              path.node.init = t.stringLiteral(prefixClasses(init.value))
+            } else if (t.isTemplateLiteral(init)) {
+              const quasis = init.quasis.map((quasi) => {
+                const raw = prefixClasses(quasi.value.raw)
+                return t.templateElement({ raw, cooked: raw })
+              })
+              path.node.init = t.templateLiteral(quasis, init.expressions)
+            } else if (t.isObjectExpression(init)) {
+              path.node.init = prefixObject(init)
+            } else if (t.isConditionalExpression(init)) {
+              path.node.init = t.conditionalExpression(
+                init.test,
+                prefixString(init.consequent),
+                prefixString(init.alternate),
+              )
+            } else if (t.isLogicalExpression(init)) {
+              const right = t.isStringLiteral(init.right)
+                ? t.stringLiteral(prefixClasses(init.right.value))
+                : init.right
+              path.node.init = t.logicalExpression(
+                init.operator,
+                init.left,
+                right,
+              )
+            }
           },
         })
 
@@ -268,11 +322,8 @@ export default function TailwindPrefixPlugin() {
 
 // Handles:
 // ✅ className="..."
-// ✅ containerClassName / *ClassName props
-// ✅ className={`...`} with ${"foo"} inside
-// ✅ className={cond ? "a" : "b"}
-// ✅ className={cond && "foo"}
-// ✅ className={clsx("foo", cond && "bar")}
-// ✅ const fooDynamicClassName = "..." | {...} | cond ? ... : ...
-// ✅ const BUTTON_CLASS / CARDS_GRID_CLASS = "..."
-// ✅ const paginationItemBaseClass / navBtnClass = `...`
+// ✅ className={\`...\`}with${"foo"}inside
+// ✅className={cond ? "a" : "b"}
+// ✅className={cond && "foo"}
+// ✅className={clsx("foo", cond && "bar")}
+// ✅const fooDynamicClassName = "..." | {...} | cond ? ... : ...`

package/scripts/tailwind/tailwind-content.js

@@ -115,9 +115,9 @@ function prefixQuotedStringsInExpression(expr) {
 
 // Handle className
 function prefixClassesInCode(code) {
-  // 1) Plain string: className="..." / containerClassName="..." / *ClassName="..."
-  code = code.replace(/([A-Za-z0-9_]*[Cc]lassName)\s*=\s*["']([^"']*)["']/g, (_, attr, classStr) => {
-    return `${attr}="${prefixStaticClasses(classStr)}"`
+  // 1) Plain string: className="..."
+  code = code.replace(/className\s*=\s*["']([^"']*)["']/g, (_, classStr) => {
+    return `className="${prefixStaticClasses(classStr)}"`
   })
 
   // code = code.replace(/className\s*=\s*["']([^"']*)["']/g, (_, classStr) => {
@@ -128,8 +128,8 @@ function prefixClassesInCode(code) {
   //   return `className="${prefixStaticClasses(classStr)}"`
   // })
 
-  // 2) Template literal: className={`...`} / *ClassName={`...`}
-  code = code.replace(/([A-Za-z0-9_]*[Cc]lassName)\s*=\s*{\s*`([\s\S]*?)`\s*}/g, (_, attr, tplBody) => {
+  // 2) Template literal: className={`...`}
+  code = code.replace(/className\s*=\s*{\s*`([\s\S]*?)`\s*}/g, (_, tplBody) => {
     const parts = tplBody.split(/(\$\{[\s\S]*?\})/g)
 
     // const rebuilt = parts
@@ -161,13 +161,13 @@ function prefixClassesInCode(code) {
         .join(' ')
         .replace(/\s+/g, ' ') // collapse multiple spaces
 
-      return `${attr}={\`${rebuilt.trim()}\`}`
+      return `className={\`${rebuilt.trim()}\`}`
   })
 
-  // 3) Ternary expressions: className={cond ? "..." : "..."} / *ClassName={...}
+  // 3) Ternary expressions: className={cond ? "..." : "..."}
   code = code.replace(
-    /([A-Za-z0-9_]*[Cc]lassName)\s*=\s*{([^{};]+?\?[^:]+:[^}]+)}/g,
-    (match, attr, inner) => {
+    /className\s*=\s*{([^{};]+?\?[^:]+:[^}]+)}/g,
+    (match, inner) => {
       const ternaryMatch = inner.match(
         /^(.*?\?)\s*(['"][^'"]*['"])\s*:\s*(['"][^'"]*['"])\s*$/,
       )
@@ -183,43 +183,42 @@ function prefixClassesInCode(code) {
         (_, q, cls) => `${q}${prefixStaticClasses(cls)}${q}`,
       )
 
-      return `${attr}={${condition} ${prefixedTrue} : ${prefixedFalse}}`
+      return `className={${condition} ${prefixedTrue} : ${prefixedFalse}}`
     },
   )
 
-  // 4) Variables with "DynamicClassName" or suffix `_CLASS` (quoted; no semicolon required)
+  // 4) Variables with "DynamicClassName" (supports TypeScript annotations like `: any`)
   code = code.replace(
-    /(const|let|var)\s+([A-Za-z0-9_]*(?:DynamicClassName[A-Za-z0-9_]*|_CLASS))\s*(?::\s*([^=]+))?\s*=\s*(['"`])([\s\S]*?)\4/g,
-    (match, decl, varName, typeAnnotation, quote, value) => {
-      const typeSuffix = typeAnnotation ? `: ${typeAnnotation.trim()}` : ''
-      if (quote === '`') {
-        return `${decl} ${varName}${typeSuffix} = \`${prefixTemplateLiteralBody(value)}\``
-      }
-      return `${decl} ${varName}${typeSuffix} = ${quote}${prefixStaticClasses(value)}${quote}`
-    },
-  )
-
-  // 4b) DynamicClassName / _CLASS object or ternary values (semicolon-terminated)
-  code = code.replace(
-    /(const|let|var)\s+([A-Za-z0-9_]*(?:DynamicClassName[A-Za-z0-9_]*|_CLASS))\s*(?::\s*([^=]+))?\s*=\s*(\{[\s\S]*?\}|.+\?.+:.+);/g,
+    /(const|let|var)\s+([A-Za-z0-9_]*DynamicClassName[A-Za-z0-9_]*)\s*(?::\s*([^=]+))?\s*=\s*([\s\S]*?);/g,
     (match, decl, varName, typeAnnotation, value) => {
       const typeSuffix = typeAnnotation ? `: ${typeAnnotation.trim()}` : ''
       const trimmed = value.trim()
-      if (/^\{[\s\S]*\}$/.test(trimmed) || /\?.*:/.test(trimmed)) {
+      if (/^\{[\s\S]*\}$/.test(trimmed)) {
+        return `${decl} ${varName}${typeSuffix} = ${prefixValueStrings(value)};`
+      }
+      if (/\?.*:/.test(trimmed)) {
         return `${decl} ${varName}${typeSuffix} = ${prefixValueStrings(value)};`
       }
+      if (/^["'`]/.test(trimmed)) {
+        if (trimmed.startsWith('`')) {
+          const body = trimmed.slice(1, -1)
+          return `${decl} ${varName}${typeSuffix} = \`${prefixTemplateLiteralBody(body)}\`;`
+        }
+        const cls = trimmed.slice(1, -1)
+        return `${decl} ${varName}${typeSuffix} = "${prefixStaticClasses(cls)}";`
+      }
       return match
     },
   )
 
-  // 5) Handle classNames(...) or clsx(...) on *ClassName props
+  // 5) Handle classNames(...) or clsx(...)
   code = code.replace(
-    /([A-Za-z0-9_]*[Cc]lassName)\s*=\s*{?\s*(classNames|clsx)\(([\s\S]*?)\)}?/g,
-    (match, attr, fnName, args) => {
+    /className\s*=\s*{?\s*(classNames|clsx)\(([\s\S]*?)\)}?/g,
+    (match, fnName, args) => {
       const transformedArgs = args.replace(/(['"])(.*?)\1/g, (_, q, cls) => {
         return `${q}${prefixStaticClasses(cls)}${q}`
       })
-      return `${attr}={${fnName}(${transformedArgs})}`
+      return `className={${fnName}(${transformedArgs})}`
     },
   )
 

package/scripts/vite/create-dev-server-config.mjs

@@ -48,8 +48,7 @@ export async function createDevServerViteConfig(options = {}) {
   ])
 
   return defineConfig(async ({ mode, command }) => {
-    const usePrefix = isPrefix(mode)
-    const prefixPlugins = usePrefix
+    const prefixPlugins = isPrefix(mode)
       ? [
           (await import('../tailwind/prefix-plugin.js')).default(),
           (await import('../tailwind/tailwind-content-plugin.js')).default(),
@@ -62,20 +61,10 @@ export async function createDevServerViteConfig(options = {}) {
         bootstrapShimResolver({ bootstrapShim, bootstrapGreenfieldShim, kitRoot }),
         resolveFromProjectRoot(projectRoot, kitRoot),
         ...(command === 'serve' ? [sdkLogBridge(), moduleConfigStore(projectRoot)] : []),
-        // Prefix must run before React / compiler so JSX className is still in the source.
-        ...prefixPlugins,
         ...(hasTanStackRoutes ? [TanStackRouterVite({ autoCodeSplitting: false })] : []),
-        viteReact(
-          usePrefix
-            ? {
-                babel: {
-                  // Match production: compiler rewrites className after the prefix pass.
-                  plugins: [],
-                },
-              }
-            : createDevReactPluginOptions(),
-        ),
+        viteReact(createDevReactPluginOptions()),
         tailwindcss(),
+        ...prefixPlugins,
       ],
       resolve: {
         dedupe: [

package/scripts/vite/portal-build-shared.js

@@ -135,16 +135,11 @@ function prodDefaultDataStub(mode) {
 
 export function portalPlugins(mode, { codeSplitting = false, routeFileIgnorePattern } = {}) {
   const routeIgnore = routeFileIgnorePattern ?? (isPrefix(mode) ? 'dev\\.' : undefined)
-  const prefixPlugins = isPrefix(mode)
-    ? [tailwindPrefixPlugin(), TailwindContentPlugin()]
-    : []
   return [
     prodDevModuleConfigRouteStub(mode),
     prodDevHubSpotLiveStub(mode),
     prodSdkTerminalLogSinksStub(mode),
     prodDefaultDataStub(mode),
-    // Prefix must run before React / compiler so JSX className is still in the source.
-    ...prefixPlugins,
     TanStackRouterVite({
       autoCodeSplitting: codeSplitting,
       ...(routeIgnore ? { routeFileIgnorePattern: routeIgnore } : {}),
@@ -157,6 +152,9 @@ export function portalPlugins(mode, { codeSplitting = false, routeFileIgnorePatt
       },
     }),
     tailwindcss(),
+    ...(isPrefix(mode)
+      ? [tailwindPrefixPlugin(), TailwindContentPlugin()]
+      : []),
   ]
 }
 

package/src/dev-module-config/__tests__/fixtures/golden-module.fixture.ts

@@ -16,7 +16,6 @@ export const goldenModuleFixture: ModuleFieldValues = {
   menu_options: {
     hubspot_defined_object: true,
     hubspot_custom_object: false,
-    custom_menu: true,
     objects: [
       {
         tab_name: 'Contacts',
@@ -27,7 +26,6 @@ export const goldenModuleFixture: ModuleFieldValues = {
       },
     ],
     hubspot_custom_objects: [],
-    custom_menus: [],
   },
   other_options: {
     show_company_name: true,

package/src/dev-module-config/__tests__/flatten-visible-fields.test.ts

@@ -4,7 +4,7 @@ import fieldsSchema from './fixtures/fields.json'
 import { goldenModuleFixture } from './fixtures/golden-module.fixture'
 import type { HubSpotFieldDefinition } from '../schema/types'
 import { HUBSPOT_ONLY_FIELD_NAMES, MODULE_CONFIG_UI_HIDDEN_FIELD_NAMES } from '../schema/types'
-import { flattenVisibleFields, isFieldVisible } from '../schema/visibility'
+import { flattenVisibleFields } from '../schema/visibility'
 
 const goldenFields = fieldsSchema as Array<HubSpotFieldDefinition>
 
@@ -105,36 +105,3 @@ describe('flattenVisibleFields', () => {
     })
   })
 })
-
-describe('isFieldVisible nested repeater items', () => {
-  const buttonNameField: HubSpotFieldDefinition = {
-    name: 'button_name',
-    label: 'Button Name',
-    type: 'text',
-    visibility: {
-      controlling_field_path: 'home.dashboard_cards.properties.property_value_show_as',
-      controlling_value_regex: 'button',
-      operator: 'EQUAL',
-    },
-  }
-
-  it('shows fields from nested Display Properties item values', () => {
-    expect(
-      isFieldVisible(buttonNameField, {
-        moduleValues: {},
-        repeaterPath: 'home.dashboard_cards.properties',
-        itemValues: { property_value_show_as: 'button' },
-      }),
-    ).toBe(true)
-  })
-
-  it('hides nested fields when the controlling item value does not match', () => {
-    expect(
-      isFieldVisible(buttonNameField, {
-        moduleValues: {},
-        repeaterPath: 'home.dashboard_cards.properties',
-        itemValues: { property_value_show_as: 'simpleText' },
-      }),
-    ).toBe(false)
-  })
-})

package/src/dev-module-config/__tests__/module-config-transform.test.ts

@@ -41,33 +41,6 @@ describe('buildHubSpotDataFromFields', () => {
     expect(built.enableDashboardCards).toBe(true)
     expect(built.sidebarMenuOptions.length).toBeGreaterThan(0)
   })
-
-  it('maps enabled custom menu items into sidebarMenuOptions', () => {
-    const built = buildHubSpotDataFromFields({
-      ...goldenModuleFixture,
-      menu_options: {
-        ...(goldenModuleFixture.menu_options as Record<string, unknown>),
-        custom_menu: true,
-        custom_menus: [
-          {
-            menu_name: 'Help Center',
-            menu_url: 'help.example.com',
-            icon_svg_code: '<svg></svg>',
-            select_option: 'iframe',
-          },
-        ],
-      },
-    })
-
-    expect(built.sidebarMenuOptions).toContainEqual(
-      expect.objectContaining({
-        label: 'Help Center',
-        menuUrl: 'https://help.example.com',
-        selectOption: 'iframe',
-        objectType: 'CUSTOM_MENU',
-      }),
-    )
-  })
 })
 
 describe('buildCssVarsFromFields', () => {