@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/src/extractor/createLogger.ts

@@ -1,41 +0,0 @@
-import { basename } from 'node:path'
-
-import type { TamaguiOptions } from '../types'
-import { getPrefixLogs } from './getPrefixLogs'
-
-export function createLogger(sourcePath: string, options: TamaguiOptions) {
-  const shouldLogTiming = options.logTimings ?? true
-  const start = Date.now()
-  const mem =
-    process.env.TAMAGUI_SHOW_MEMORY_USAGE && shouldLogTiming
-      ? process.memoryUsage()
-      : null
-
-  return (res) => {
-    if (!shouldLogTiming) {
-      return
-    }
-
-    const memUsed = mem
-      ? Math.round(((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204) * 10) /
-        10
-      : 0
-    const path = basename(sourcePath || '')
-      .replace(/\.[jt]sx?$/, '')
-      .slice(0, 22)
-      .trim()
-      .padEnd(24)
-
-    const numOptimized = `${res.optimized + res.styled}`.padStart(3)
-    const numFound = `${res.found + res.styled}`.padStart(3)
-    const numFlattened = `${res.flattened}`.padStart(3)
-    const memory = memUsed ? ` ${memUsed}MB` : ''
-    const timing = Date.now() - start
-    const timingStr = `${timing}ms`.padStart(6)
-    const pre = getPrefixLogs(options)
-    const memStr = memory ? `(${memory})` : ''
-    console.info(
-      `${pre} ${path}   ·  ${numFound} found   ·  ${numOptimized} opt   ·  ${numFlattened} flat  ${timingStr} ${memStr}`
-    )
-  }
-}

package/src/extractor/ensureImportingConcat.ts

@@ -1,36 +0,0 @@
-import type { NodePath } from '@babel/traverse'
-import * as t from '@babel/types'
-
-const importConcatPkg = '@tamagui/helpers'
-
-export function ensureImportingConcat(path: NodePath<t.Program>) {
-  const bodyPath = path.get('body')
-  const imported: NodePath<t.ImportDeclaration> | undefined = bodyPath.find(
-    (x) => x.isImportDeclaration() && x.node.source.value === importConcatPkg
-  ) as any
-  const importSpecifier = t.importSpecifier(
-    t.identifier('concatClassName'),
-    t.identifier('concatClassName')
-  )
-
-  if (!imported) {
-    path.node.body.push(
-      t.importDeclaration([importSpecifier], t.stringLiteral(importConcatPkg))
-    )
-    return
-  }
-
-  const specifiers = imported.node.specifiers
-  const alreadyImported = specifiers.some(
-    (x) =>
-      t.isImportSpecifier(x) &&
-      t.isIdentifier(x.imported) &&
-      x.imported.name === 'concatClassName'
-  )
-
-  if (!alreadyImported) {
-    specifiers.push(
-      t.importSpecifier(t.identifier('concatClassName'), t.identifier('concatClassName'))
-    )
-  }
-}

package/src/extractor/errors.ts

@@ -1 +0,0 @@
-export class BailOptimizationError extends Error {}

package/src/extractor/evaluateAstNode.ts

@@ -1,136 +0,0 @@
-import * as t from '@babel/types'
-
-export function evaluateAstNode(
-  exprNode: t.Node | undefined | null,
-  evalFn?: (node: t.Node) => any,
-  shouldPrintDebug?: boolean | 'verbose'
-): any {
-  if (exprNode === undefined) {
-    return undefined
-  }
-
-  // null === boolean true (at least in our use cases for jsx eval)
-  if (exprNode === null) {
-    return true
-  }
-
-  if (t.isJSXExpressionContainer(exprNode)) {
-    return evaluateAstNode(exprNode.expression)
-  }
-
-  // loop through ObjectExpression keys
-  if (t.isObjectExpression(exprNode)) {
-    const ret: Record<string, any> = {}
-    for (let idx = -1, len = exprNode.properties.length; ++idx < len; ) {
-      const value = exprNode.properties[idx]
-
-      if (!t.isObjectProperty(value)) {
-        throw new Error('evaluateAstNode can only evaluate object properties')
-      }
-
-      let key: string | number | null | undefined | boolean
-      if (value.computed) {
-        if (typeof evalFn !== 'function') {
-          throw new Error(
-            'evaluateAstNode does not support computed keys unless an eval function is provided'
-          )
-        }
-        key = evaluateAstNode(value.key, evalFn)
-      } else if (t.isIdentifier(value.key)) {
-        key = value.key.name
-      } else if (t.isStringLiteral(value.key) || t.isNumericLiteral(value.key)) {
-        key = value.key.value
-      } else {
-        throw new Error('Unsupported key type: ' + value.key.type)
-      }
-
-      if (typeof key !== 'string' && typeof key !== 'number') {
-        throw new Error('key must be either a string or a number')
-      }
-
-      ret[key] = evaluateAstNode(value.value, evalFn)
-    }
-    return ret
-  }
-
-  if (t.isArrayExpression(exprNode)) {
-    return exprNode.elements.map((x) => {
-      return evaluateAstNode(x as any, evalFn)
-    })
-  }
-
-  if (t.isUnaryExpression(exprNode) && exprNode.operator === '-') {
-    const ret = evaluateAstNode(exprNode.argument, evalFn)
-    if (ret == null) {
-      return null
-    }
-    return -ret
-  }
-
-  if (t.isTemplateLiteral(exprNode)) {
-    if (typeof evalFn !== 'function') {
-      throw new Error(
-        'evaluateAstNode does not support template literals unless an eval function is provided'
-      )
-    }
-
-    let ret = ''
-    for (let idx = -1, len = exprNode.quasis.length; ++idx < len; ) {
-      const quasi = exprNode.quasis[idx]
-      const expr = exprNode.expressions[idx]
-      ret += quasi.value.raw
-      if (expr) {
-        ret += evaluateAstNode(expr, evalFn)
-      }
-    }
-    return ret
-  }
-
-  // In the interest of representing the "evaluated" prop
-  // as the user intended, we support negative null. Why not.
-  if (t.isNullLiteral(exprNode)) {
-    return null
-  }
-
-  if (
-    t.isNumericLiteral(exprNode) ||
-    t.isStringLiteral(exprNode) ||
-    t.isBooleanLiteral(exprNode)
-  ) {
-    // In the interest of representing the "evaluated" prop
-    // as the user intended, we support negative null. Why not.
-    return exprNode.value
-  }
-
-  if (t.isBinaryExpression(exprNode)) {
-    if (exprNode.operator === '+') {
-      return (
-        evaluateAstNode(exprNode.left, evalFn) + evaluateAstNode(exprNode.right, evalFn)
-      )
-    }
-    if (exprNode.operator === '-') {
-      return (
-        evaluateAstNode(exprNode.left, evalFn) - evaluateAstNode(exprNode.right, evalFn)
-      )
-    }
-    if (exprNode.operator === '*') {
-      return (
-        evaluateAstNode(exprNode.left, evalFn) * evaluateAstNode(exprNode.right, evalFn)
-      )
-    }
-    if (exprNode.operator === '/') {
-      return (
-        evaluateAstNode(exprNode.left, evalFn) / evaluateAstNode(exprNode.right, evalFn)
-      )
-    }
-  }
-
-  // if we've made it this far, the value has to be evaluated
-  if (typeof evalFn !== 'function') {
-    throw new Error(
-      'evaluateAstNode does not support non-literal values unless an eval function is provided'
-    )
-  }
-
-  return evalFn(exprNode)
-}

package/src/extractor/extractHelpers.ts

@@ -1,211 +0,0 @@
-import { basename } from 'node:path'
-
-import generate from '@babel/generator'
-import type { NodePath } from '@babel/traverse'
-import * as t from '@babel/types'
-import findRoot from 'find-root'
-
-import { memoize } from '../helpers/memoize'
-import type { ExtractedAttr, TamaguiOptionsWithFileInfo, Ternary } from '../types'
-
-// import { astToLiteral } from './literalToAst'
-
-export function isPresent<T extends object>(
-  input: null | void | undefined | T
-): input is T {
-  return input != null
-}
-
-export function isSimpleSpread(node: t.JSXSpreadAttribute) {
-  return t.isIdentifier(node.argument) || t.isMemberExpression(node.argument)
-}
-
-export const attrStr = (attr?: ExtractedAttr) => {
-  return !attr
-    ? ''
-    : attr.type === 'attr'
-      ? getNameAttr(attr.value)
-      : attr.type === 'ternary'
-        ? `...${ternaryStr(attr.value)}`
-        : `${attr.type}(${objToStr(attr.value)})`
-}
-
-export const objToStr = (obj: any, spacer = ', ') => {
-  if (!obj) {
-    return `${obj}`
-  }
-  return `{${Object.entries(obj)
-    .map(
-      ([k, v]) =>
-        `${k}:${
-          Array.isArray(v)
-            ? `[...]`
-            : v && typeof v === 'object'
-              ? `${objToStr(v, ',')}`
-              : JSON.stringify(v)
-        }`
-    )
-    .join(spacer)}}`
-}
-
-const getNameAttr = (attr: t.JSXAttribute | t.JSXSpreadAttribute) => {
-  if (t.isJSXSpreadAttribute(attr)) {
-    return `...${attr.argument['name']}`
-  }
-  return 'name' in attr ? attr.name.name : `unknown-${attr['type']}`
-}
-
-export const ternaryStr = (x: Ternary) => {
-  const conditional = t.isIdentifier(x.test)
-    ? x.test.name
-    : t.isMemberExpression(x.test)
-      ? [x.test.object['name'], x.test.property['name']]
-      : // @ts-ignore
-        generate(x.test as any).code
-  return [
-    'ternary(',
-    conditional,
-    isFilledObj(x.consequent) ? ` ? ${objToStr(x.consequent)}` : ' ? 🚫',
-    isFilledObj(x.alternate) ? ` : ${objToStr(x.alternate)}` : ' : 🚫',
-    ')',
-  ]
-    .flat()
-    .join('')
-}
-
-const isFilledObj = (obj: any) => obj && Object.keys(obj).length
-
-export function findComponentName(scope) {
-  const componentName = ''
-  let cur = scope.path
-  while (cur.parentPath && !t.isProgram(cur.parentPath.parent)) {
-    cur = cur.parentPath
-  }
-  let node = cur.parent
-  if (t.isExportNamedDeclaration(node)) {
-    node = node.declaration
-  }
-  if (t.isVariableDeclaration(node)) {
-    const [dec] = node.declarations
-    if (t.isVariableDeclarator(dec) && t.isIdentifier(dec.id)) {
-      return dec.id.name
-    }
-  }
-  if (t.isFunctionDeclaration(node)) {
-    return node.id?.name
-  }
-  return componentName
-}
-
-export function isValidThemeHook(
-  props: TamaguiOptionsWithFileInfo,
-  jsxPath: NodePath<t.JSXElement>,
-  n: t.MemberExpression,
-  sourcePath?: string
-) {
-  if (!t.isIdentifier(n.object) || !t.isIdentifier(n.property)) return false
-  const bindings = jsxPath.scope.getAllBindings()
-  const binding = bindings[n.object.name]
-  if (!binding?.path) return false
-  if (!binding.path.isVariableDeclarator()) return false
-  const init = binding.path.node.init
-  if (!init || !t.isCallExpression(init)) return false
-  if (!t.isIdentifier(init.callee)) return false
-  // TODO could support renaming useTheme by looking up import first
-  if (init.callee.name !== 'useTheme') return false
-  const importNode = binding.scope.getBinding('useTheme')?.path.parent
-  if (!t.isImportDeclaration(importNode)) return false
-  if (sourcePath && !isValidImport(props, sourcePath)) {
-    return false
-  }
-  return true
-}
-
-export const isInsideComponentPackage = (
-  props: TamaguiOptionsWithFileInfo,
-  moduleName: string
-) => {
-  return getValidComponentsPaths(props).some((path) => {
-    return moduleName.startsWith(path)
-  })
-}
-
-export const isComponentPackage = (
-  props: TamaguiOptionsWithFileInfo,
-  srcName: string
-) => {
-  return getValidComponentsPaths(props).some((path) => {
-    return srcName.startsWith(path)
-  })
-}
-
-export function getValidComponent(
-  props: TamaguiOptionsWithFileInfo,
-  moduleName: string,
-  componentName: string
-) {
-  // must be uppercase of course
-  if (componentName[0].toUpperCase() !== componentName[0]) {
-    return false
-  }
-
-  for (const loaded of props.allLoadedComponents) {
-    if (!loaded) continue
-    const isInModule = moduleName === '*' || moduleName.startsWith(loaded.moduleName)
-    const foundComponent = loaded.nameToInfo[componentName]
-    if (isInModule && foundComponent) {
-      return foundComponent
-    }
-  }
-
-  return null
-}
-
-export const isValidModule = (props: TamaguiOptionsWithFileInfo, moduleName: string) => {
-  if (typeof moduleName !== 'string') {
-    throw new Error(`No module name`)
-  }
-  const isLocal = moduleName.startsWith('.')
-  return {
-    isLocal,
-    isValid: isLocal
-      ? isInsideComponentPackage(props, moduleName)
-      : isComponentPackage(props, moduleName),
-  }
-}
-
-export const getValidImport = (
-  props: TamaguiOptionsWithFileInfo,
-  moduleName: string,
-  componentName?: string
-) => {
-  const { isValid, isLocal } = isValidModule(props, moduleName)
-  if (!isValid || !componentName) {
-    return null
-  }
-  return getValidComponent(props, isLocal ? '*' : moduleName, componentName) || null
-}
-
-export const isValidImport = (
-  props: TamaguiOptionsWithFileInfo,
-  moduleName: string,
-  componentName?: string
-) => {
-  if (!componentName) {
-    return isValidModule(props, moduleName).isValid
-  }
-  return Boolean(getValidImport(props, moduleName, componentName))
-}
-
-const getValidComponentPackages = memoize((props: TamaguiOptionsWithFileInfo) => {
-  // just always look for `tamagui` and `@tamagui/core`
-  return [...new Set(['@tamagui/core', 'tamagui', ...(props.components || [])])]
-})
-
-export const getValidComponentsPaths = memoize((props: TamaguiOptionsWithFileInfo) => {
-  return getValidComponentPackages(props).flatMap((pkg) => {
-    const root = findRoot(pkg)
-    const based = basename(root)
-    return [based, pkg].filter(Boolean)
-  })
-})

package/src/extractor/extractMediaStyle.ts

@@ -1,194 +0,0 @@
-import type { NodePath } from '@babel/traverse'
-import * as t from '@babel/types'
-import type { TamaguiInternalConfig } from '@tamagui/core'
-import * as core from '@tamagui/core'
-import type { ViewStyle } from 'react-native'
-
-import { requireTamaguiCore } from '../helpers/requireTamaguiCore'
-import type { StyleObject, TamaguiOptionsWithFileInfo, Ternary } from '../types'
-import { isPresent, isValidImport } from './extractHelpers'
-
-export function extractMediaStyle(
-  props: TamaguiOptionsWithFileInfo,
-  ternary: Ternary,
-  jsxPath: NodePath<t.JSXElement>,
-  tamaguiConfig: TamaguiInternalConfig,
-  sourcePath: string,
-  importance = 0,
-  shouldPrintDebug: boolean | 'verbose' = false
-) {
-  const { getCSSStylesAtomic } = requireTamaguiCore('web')
-  const mt = getMediaQueryTernary(props, ternary, jsxPath, sourcePath)
-  if (!mt) {
-    return null
-  }
-  const { key } = mt
-  const mq = tamaguiConfig.media[key]
-  if (!mq) {
-    console.error(`Media query "${key}" not found: ${Object.keys(tamaguiConfig.media)}`)
-    return null
-  }
-  const getStyleObj = (styleObj: ViewStyle | null, negate = false) => {
-    return styleObj ? { styleObj, negate } : null
-  }
-  const styleOpts = [
-    getStyleObj(ternary.consequent, false),
-    getStyleObj(ternary.alternate, true),
-  ].filter(isPresent)
-  if (shouldPrintDebug && !styleOpts.length) {
-    console.info('  media query, no styles?')
-    return null
-  }
-  // for now order first strongest
-  const mediaKeys = Object.keys(tamaguiConfig.media)
-  const mediaKeyPrecendence = mediaKeys.reduce((acc, cur, i) => {
-    acc[cur] = new Array(importance + 1).fill(':root').join('')
-    return acc
-  }, {})
-  let mediaStyles: StyleObject[] = []
-
-  // TODO this should NOT be here
-  // this should be done using the same logic as createMediaStyle
-
-  for (const { styleObj, negate } of styleOpts) {
-    const styles = getCSSStylesAtomic(styleObj as any)
-
-    const singleMediaStyles = styles.map((style) => {
-      const mediaStyle = core.createMediaStyle(
-        style,
-        key,
-        tamaguiConfig.media,
-        true,
-        negate
-      )
-      const className = `.${mediaStyle[core.StyleObjectIdentifier]}`
-      return {
-        ...mediaStyle,
-        className,
-      }
-    })
-
-    if (shouldPrintDebug === 'verbose') {
-      console.info(
-        '  media styles:',
-        importance,
-        styleObj,
-        singleMediaStyles.map((x) => x[core.StyleObjectIdentifier]).join(', ')
-      )
-    }
-    // add to output
-    mediaStyles = [...mediaStyles, ...singleMediaStyles]
-  }
-  // filter out
-  ternary.remove()
-  return { mediaStyles, ternaryWithoutMedia: mt.ternaryWithoutMedia }
-}
-
-function getMediaQueryTernary(
-  props: TamaguiOptionsWithFileInfo,
-  ternary: Ternary,
-  jsxPath: NodePath<t.JSXElement>,
-  sourcePath: string
-): null | {
-  key: string
-  bindingName: string
-  ternaryWithoutMedia: Ternary | null
-} {
-  // this handles unwrapping logical && media query ternarys
-  // first, unwrap if it has media logicalExpression
-  if (t.isLogicalExpression(ternary.test) && ternary.test.operator === '&&') {
-    // *should* be normalized to always be on left side
-    const mediaLeft = getMediaInfoFromExpression(
-      props,
-      ternary.test.left,
-      jsxPath,
-      sourcePath,
-      ternary.inlineMediaQuery
-    )
-    if (mediaLeft) {
-      return {
-        ...mediaLeft,
-        ternaryWithoutMedia: {
-          ...ternary,
-          test: ternary.test.right,
-        },
-      }
-    }
-  }
-  // const media = useMedia()
-  // ... media.sm
-  const result = getMediaInfoFromExpression(
-    props,
-    ternary.test,
-    jsxPath,
-    sourcePath,
-    ternary.inlineMediaQuery
-  )
-  if (result) {
-    return {
-      ...result,
-      ternaryWithoutMedia: null,
-    }
-  }
-  return null
-}
-
-function getMediaInfoFromExpression(
-  props: TamaguiOptionsWithFileInfo,
-  test: t.Expression,
-  jsxPath: NodePath<t.JSXElement>,
-  sourcePath: string,
-  inlineMediaQuery?: string
-) {
-  if (inlineMediaQuery) {
-    return {
-      key: inlineMediaQuery,
-      bindingName: inlineMediaQuery,
-    }
-  }
-  if (
-    t.isMemberExpression(test) &&
-    t.isIdentifier(test.object) &&
-    t.isIdentifier(test.property)
-  ) {
-    const name = test.object['name']
-    const key = test.property['name']
-    const bindings = jsxPath.scope.getAllBindings()
-    const binding = bindings[name]
-    if (!binding) return false
-    const bindingNode = binding.path?.node
-    if (!t.isVariableDeclarator(bindingNode) || !bindingNode.init) return false
-    if (!isValidMediaCall(props, jsxPath, bindingNode.init, sourcePath)) return false
-    return { key, bindingName: name }
-  }
-  if (t.isIdentifier(test)) {
-    const key = test.name
-    const node = jsxPath.scope.getBinding(test.name)?.path?.node
-    if (!t.isVariableDeclarator(node)) return false
-    if (!node.init || !isValidMediaCall(props, jsxPath, node.init, sourcePath))
-      return false
-    return { key, bindingName: key }
-  }
-  return null
-}
-
-export function isValidMediaCall(
-  props: TamaguiOptionsWithFileInfo,
-  jsxPath: NodePath<t.JSXElement>,
-  init: t.Expression,
-  sourcePath: string
-) {
-  if (!init || !t.isCallExpression(init)) return false
-  if (!t.isIdentifier(init.callee)) return false
-  // TODO could support renaming useMedia by looking up import first
-  if (init.callee.name !== 'useMedia') return false
-  const bindings = jsxPath.scope.getAllBindings()
-  const mediaBinding = bindings['useMedia']
-  if (!mediaBinding) return false
-  const useMediaImport = mediaBinding.path.parent
-  if (!t.isImportDeclaration(useMediaImport)) return false
-  if (!isValidImport(props, sourcePath)) {
-    return false
-  }
-  return true
-}