@tamagui/static 1.0.1-beta.99 → 1.0.1-rc.0

package/src/getPragmaOptions.ts

@@ -0,0 +1,53 @@
+export function getPragmaOptions({
+  source,
+  path,
+  disableCommentCheck,
+}: {
+  source: string
+  path: string
+  disableCommentCheck?: boolean
+}) {
+  if (!disableCommentCheck && !source.startsWith('//') && !source.startsWith('/*')) {
+    return {
+      shouldPrintDebug: false,
+      shouldDisable: false,
+    }
+  }
+
+  let shouldPrintDebug: boolean | 'verbose' = false
+  let shouldDisable = false
+
+  // try and avoid too much parsing but sometimes esbuild adds helpers above..
+  const firstLine = source.slice(0, 800).split('\n')[0]
+
+  if (firstLine.includes('tamagui-ignore')) {
+    shouldDisable = true
+  }
+
+  if (firstLine.includes('debug')) {
+    shouldPrintDebug = true
+  }
+
+  if (firstLine.includes('debug-verbose')) {
+    shouldPrintDebug = 'verbose'
+  }
+
+  if (process.env.TAMAGUI_DEBUG_FILE) {
+    if (path.includes(process.env.TAMAGUI_DEBUG_FILE)) {
+      shouldPrintDebug = 'verbose'
+    }
+  }
+
+  if (process.env.DEBUG?.includes('tamagui')) {
+    shouldPrintDebug = true
+  }
+
+  if (process.env.DEBUG?.includes('tamagui-verbose')) {
+    shouldPrintDebug = 'verbose'
+  }
+
+  return {
+    shouldPrintDebug,
+    shouldDisable,
+  }
+}

package/src/helpers/memoize.ts

@@ -0,0 +1,21 @@
+// @ts-nocheck
+export function memoize(func?: Function, resolver?: any) {
+  if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) {
+    throw new TypeError('Expected a function')
+  }
+  const memoized = function (...args) {
+    const key = resolver ? resolver.apply(this, args) : args[0]
+    const cache = memoized.cache
+
+    if (cache.has(key)) {
+      return cache.get(key)
+    }
+    const result = func.apply(this, args)
+    memoized.cache = cache.set(key, result) || cache
+    return result
+  }
+  memoized.cache = new (memoize.Cache || Map)()
+  return memoized
+}
+
+memoize.Cache = Map

package/src/index.ts

@@ -1,10 +1,11 @@
 process.env.TAMAGUI_COMPILE_PROCESS = '1'
 
-export { TamaguiOptions } from './types'
-export { createExtractor } from './extractor/createExtractor'
-export { literalToAst } from './extractor/literalToAst'
-export * from './constants'
-export * from './extractor/extractToClassNames'
-export * from './extractor/extractHelpers'
-export * from '@tamagui/patch-rnw'
-export * from './extractor/loadTamagui'
+export { TamaguiOptions } from './types.js'
+export { createExtractor } from './extractor/createExtractor.js'
+export { literalToAst } from './extractor/literalToAst.js'
+export * from './constants.js'
+export * from './extractor/extractToClassNames.js'
+export * from './extractor/extractHelpers.js'
+export * from './extractor/loadTamagui.js'
+export * from './require.js'
+export * from './getPragmaOptions.js'

package/src/require.ts

@@ -0,0 +1,103 @@
+import { relative, sep } from 'path'
+
+import { SHOULD_DEBUG } from './constants.js'
+
+const nameToPaths = {}
+const Module = require('module')
+const og = Module.prototype.require
+globalThis['ogRequire'] = og
+
+export const getNameToPaths = () => nameToPaths
+
+export function registerRequire() {
+  if (Module.prototype.require !== globalThis['ogRequire']) {
+    // eslint-disable-next-line no-console
+    console.warn('didnt unregister before re-registering')
+    process.exit(1)
+  }
+
+  const proxyWorm = require('@tamagui/proxy-worm')
+  // TODO can swap with react-native-web-lite
+  const rnw = require('react-native-web')
+  const core = require('@tamagui/core-node')
+
+  Module.prototype.require = function (path: string) {
+    if (/\.(gif|jpe?g|png|svg|ttf|otf|woff2?|bmp|webp)$/.test(path)) {
+      return {}
+    }
+    if (
+      path === '@gorhom/bottom-sheet' ||
+      path.startsWith('react-native-reanimated') ||
+      path === 'expo-linear-gradient' ||
+      path === '@expo/vector-icons'
+    ) {
+      return proxyWorm
+    }
+    if (
+      path.startsWith('react-native') &&
+      // allow our rnw.tsx imports through
+      !path.startsWith('react-native-web/dist/cjs/exports'.replace(/\//g, sep))
+    ) {
+      return rnw
+    }
+    if (path === '@tamagui/core') {
+      return core
+    }
+    try {
+      const out = og.apply(this, arguments)
+      // only for studio disable for now
+      // if (!nameToPaths[path]) {
+      //   if (out && typeof out === 'object') {
+      //     for (const key in out) {
+      //       try {
+      //         const conf = out[key]?.staticConfig as StaticConfig
+      //         if (conf) {
+      //           if (conf.componentName) {
+      //             nameToPaths[conf.componentName] ??= new Set()
+      //             const fullName = path.startsWith('.')
+      //               ? join(`${this.path.replace(/dist(\/cjs)?/, 'src')}`, path)
+      //               : path
+      //             nameToPaths[conf.componentName].add(fullName)
+      //           } else {
+      //             // console.log('no name component', path)
+      //           }
+      //         }
+      //       } catch {
+      //         // ok
+      //       }
+      //     }
+      //   }
+      // }
+      return out
+    } catch (err: any) {
+      /**
+       * Allow errors to happen, we're just reading config and components but sometimes external modules cause problems
+       * We can't fix every problem, so just swap them out with proxyWorm which is a sort of generic object that can be read.
+       */
+
+      if (process.env.DEBUG?.startsWith('tamagui')) {
+        // eslint-disable-next-line no-console
+        console.error(
+          `Tamagui failed loading the pre-built tamagui.config.ts
+  
+  ${err.message}
+  ${err.stack}
+  
+    You can see if it loads in the node repl:
+  
+    require("./${relative(process.cwd(), path)}").default
+  
+  `
+        )
+      }
+
+      return proxyWorm
+    }
+  }
+
+  return Module.prototype.require
+}
+
+export function unregisterRequire() {
+  Module.prototype.require = og
+}

package/src/types.ts

@@ -1,8 +1,13 @@
-import { NodePath } from '@babel/traverse'
+import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
-import { PseudoStyles } from '@tamagui/core-node'
-import { StyleObject } from '@tamagui/core-node'
-import { ViewStyle } from 'react-native'
+import type { PseudoStyles, StaticConfig } from '@tamagui/core-node'
+import type { StyleObject } from '@tamagui/helpers'
+import type { TamaguiOptions } from '@tamagui/helpers-node'
+import type { ViewStyle } from 'react-native'
+
+import { LoadedComponents } from './index'
+
+export type { TamaguiOptions } from '@tamagui/helpers-node'
 
 export type { StyleObject } from '@tamagui/helpers'
 
@@ -12,30 +17,20 @@ export interface CacheObject {
   [key: string]: any
 }
 
-export interface TamaguiOptions {
-  // module paths you want to compile with tamagui (for example ['tamagui'])
-  components: string[]
-  // your tamagui.config.ts
-  config?: string
-  evaluateVars?: boolean
-  importsWhitelist?: string[]
-  disable?: boolean
-  disableExtraction?: boolean
-  disableDebugAttr?: boolean
-  disableExtractInlineMedia?: boolean
-  disableExtractVariables?: boolean
-  excludeReactNativeWebExports?: string[]
-  exclude?: RegExp
-  logTimings?: boolean
-  prefixLogs?: string
-
-  // probably non user options
-  cssPath?: string
-  cssData?: any
-  deoptProps?: Set<string>
-  excludeProps?: Set<string>
-  inlineProps?: Set<string>
-  forceExtractStyleDefinitions?: boolean
+export interface LogOptions {
+  clear?: boolean
+  timestamp?: boolean
+  error?: Error | null
+}
+
+export interface Logger {
+  info(msg: string, options?: LogOptions): void
+  warn(msg: string, options?: LogOptions): void
+  error(msg: string, options?: LogOptions): void
+}
+
+export type ExtractorOptions = {
+  logger?: Logger
 }
 
 export type ExtractedAttrAttr = {
@@ -56,6 +51,7 @@ export type ExtractedAttr =
   | ExtractedAttrStyle
 
 export type ExtractTagProps = {
+  parserProps: TamaguiOptionsWithFileInfo
   attrs: ExtractedAttr[]
   node: t.JSXOpeningElement
   attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any
@@ -65,14 +61,20 @@ export type ExtractTagProps = {
   lineNumbers: string
   filePath: string
   isFlattened: boolean
+  completeProps: Record<string, any>
+  staticConfig: StaticConfig
+}
+
+export type TamaguiOptionsWithFileInfo = TamaguiOptions & {
+  sourcePath: string
+  allLoadedComponents: LoadedComponents[]
 }
 
-export type ExtractorParseProps = TamaguiOptions & {
+export type ExtractorParseProps = Omit<TamaguiOptionsWithFileInfo, 'allLoadedComponents'> & {
   target: 'native' | 'html'
-  sourcePath?: string
   shouldPrintDebug?: boolean | 'verbose'
   onExtractTag: (props: ExtractTagProps) => void
-  getFlattenedNode: (props: { isTextView: boolean; tag: string }) => string
+  getFlattenedNode?: (props: { isTextView: boolean; tag: string }) => string
   extractStyledDefinitions?: boolean
   // identifer, rule
   onStyleRule?: (identifier: string, rules: string[]) => void

package/src/webpackPlugin.ts

@@ -0,0 +1,9 @@
+const pluginName = 'TamaguiWebpackPlugin'
+
+export class TamaguiWebpackPlugin {
+  apply(compiler) {
+    compiler.hooks.run.tap(pluginName, (compilation) => {
+      // console.log('The webpack build process is starting!');
+    })
+  }
+}

package/tamagui.tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  }
+}

package/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CSS_FILE_NAME = "__snack.css";
+export declare const MEDIA_SEP = "_";
+export declare const cacheDir: any;
+export declare const FAILED_EVAL: unique symbol;
+export declare const SHOULD_DEBUG: boolean | undefined;
+//# sourceMappingURL=constants.d.ts.map

package/types/extractor/accessSafe.d.ts

@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function accessSafe(obj: t.Expression, member: string): t.LogicalExpression;
+//# sourceMappingURL=accessSafe.d.ts.map

package/types/extractor/babelParse.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import * as babelParser from '@babel/parser';
+import * as t from '@babel/types';
+export declare const parserOptions: babelParser.ParserOptions;
+export declare function babelParse(code: string | Buffer): t.File;
+//# sourceMappingURL=babelParse.d.ts.map

package/types/extractor/buildClassName.d.ts

@@ -1,4 +1,7 @@
 import * as t from '@babel/types';
-import { ClassNameObject } from '../types';
-export declare function buildClassName(classNameObjects: ClassNameObject[]): t.Expression | t.StringLiteral | null;
+import type { ClassNameObject } from '../types.js';
+declare type Builder = (objects: ClassNameObject[], extras?: string) => t.Expression | t.StringLiteral | null;
+export declare const buildClassName: Builder;
+export declare const buildClassNameLogic: Builder;
+export {};
 //# sourceMappingURL=buildClassName.d.ts.map

package/types/extractor/bundle.d.ts

@@ -0,0 +1,13 @@
+import esbuild from 'esbuild';
+/**
+ * For internal loading of new files
+ */
+declare type Props = Omit<Partial<esbuild.BuildOptions>, 'entryPoints'> & {
+    outfile: string;
+    entryPoints: string[];
+    resolvePlatformSpecificEntries?: boolean;
+};
+export declare function bundle(props: Props, aliases?: Record<string, string>): Promise<esbuild.BuildResult>;
+export declare function bundleSync(props: Props, aliases?: Record<string, string>): esbuild.BuildResult;
+export {};
+//# sourceMappingURL=bundle.d.ts.map

package/types/extractor/createEvaluator.d.ts

@@ -1,8 +1,8 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import type { TamaguiConfig } from '@tamagui/core';
-export declare function createEvaluator({ tamaguiConfig, staticNamespace, sourcePath, traversePath, shouldPrintDebug, }: {
-    tamaguiConfig: TamaguiConfig;
+import { TamaguiOptionsWithFileInfo } from '../types.js';
+export declare function createEvaluator({ props, staticNamespace, sourcePath, traversePath, shouldPrintDebug, }: {
+    props: TamaguiOptionsWithFileInfo;
     staticNamespace: Record<string, any>;
     sourcePath: string;
     traversePath?: NodePath<t.JSXElement>;

package/types/extractor/createExtractor.d.ts

@@ -1,28 +1,44 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import { TamaguiInternalConfig } from '@tamagui/core-node';
-import { ExtractorParseProps } from '../types';
+import type { ExtractorOptions, ExtractorParseProps, TamaguiOptions } from '../types.js';
+import { cleanupBeforeExit } from './getStaticBindingsForScope.js';
+import { TamaguiProjectInfo } from './loadTamagui.js';
 export declare type Extractor = ReturnType<typeof createExtractor>;
-export declare function createExtractor(): {
-    getTamagui(): TamaguiInternalConfig<import("@tamagui/core-node").CreateTokens<import("@tamagui/core-node").VariableVal>, {
+declare type FileOrPath = NodePath<t.Program> | t.File;
+export declare function createExtractor({ logger }?: ExtractorOptions): {
+    options: {
+        logger: import("../types.js").Logger;
+    };
+    cleanupBeforeExit: typeof cleanupBeforeExit;
+    loadTamagui: (props: TamaguiOptions) => Promise<TamaguiProjectInfo>;
+    loadTamaguiSync: (props: TamaguiOptions) => TamaguiProjectInfo;
+    getTamagui(): import("@tamagui/core-node").TamaguiInternalConfig<import("@tamagui/core-node").CreateTokens<import("@tamagui/core-node").VariableVal>, {
         [key: string]: Partial<import("@tamagui/core-node").TamaguiBaseTheme> & {
             [key: string]: import("@tamagui/core-node").VariableVal;
         };
-    }, {}, {
-        [x: string]: {
+    }, import("@tamagui/core-node").GenericShorthands, {
+        [key: string]: {
             [key: string]: string | number;
         };
     }, {
-        [key: string]: string | {
+        [key: string]: string | any[] | {
             [key: string]: any;
         };
-    }, import("@tamagui/core-node").GenericFonts>;
-    parse: (fileOrPath: NodePath<t.Program> | t.File, { config, importsWhitelist, evaluateVars, shouldPrintDebug, sourcePath, onExtractTag, onStyleRule, getFlattenedNode, disable, disableExtraction, disableExtractInlineMedia, disableExtractVariables, disableDebugAttr, extractStyledDefinitions, prefixLogs, excludeProps, target, ...props }: ExtractorParseProps) => {
+    }, import("@tamagui/core-node").GenericFonts> | undefined;
+    parseSync: (f: FileOrPath, props: ExtractorParseProps) => {
         styled: number;
         flattened: number;
         optimized: number;
         modified: number;
         found: number;
     } | null;
+    parse: (f: FileOrPath, props: ExtractorParseProps) => Promise<{
+        styled: number;
+        flattened: number;
+        optimized: number;
+        modified: number;
+        found: number;
+    } | null>;
 };
+export {};
 //# sourceMappingURL=createExtractor.d.ts.map

package/types/extractor/ensureImportingConcat.d.ts

@@ -0,0 +1,4 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function ensureImportingConcat(path: NodePath<t.Program>): void;
+//# sourceMappingURL=ensureImportingConcat.d.ts.map

package/types/extractor/evaluateAstNode.d.ts

@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function evaluateAstNode(exprNode: t.Node | undefined | null, evalFn?: (node: t.Node) => any, shouldPrintDebug?: boolean | 'verbose'): any;
+//# sourceMappingURL=evaluateAstNode.d.ts.map

package/types/extractor/extractHelpers.d.ts

@@ -1,12 +1,24 @@
 import type { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import { ExtractedAttr, Ternary } from '../types';
+import type { ExtractedAttr, TamaguiOptionsWithFileInfo, Ternary } from '../types.js';
 export declare function isPresent<T extends Object>(input: null | void | undefined | T): input is T;
 export declare function isSimpleSpread(node: t.JSXSpreadAttribute): boolean;
 export declare const attrStr: (attr?: ExtractedAttr) => string | t.JSXIdentifier;
 export declare const objToStr: (obj: any, spacer?: string) => any;
 export declare const ternaryStr: (x: Ternary) => string;
 export declare function findComponentName(scope: any): string | undefined;
-export declare function isValidThemeHook(jsxPath: NodePath<t.JSXElement>, n: t.MemberExpression, sourcePath: string): boolean;
-export declare const isInsideTamagui: (srcName: string) => boolean;
+export declare function isValidThemeHook(props: TamaguiOptionsWithFileInfo, jsxPath: NodePath<t.JSXElement>, n: t.MemberExpression, sourcePath: string): boolean;
+export declare const isInsideComponentPackage: (props: TamaguiOptionsWithFileInfo, moduleName: string) => any;
+export declare const isComponentPackage: (props: TamaguiOptionsWithFileInfo, srcName: string) => any;
+export declare function getValidComponent(props: TamaguiOptionsWithFileInfo, moduleName: string, componentName: string): false | {
+    staticConfig: import("@tamagui/core-node").StaticConfigParsed;
+} | null;
+export declare const isValidModule: (props: TamaguiOptionsWithFileInfo, moduleName: string) => {
+    isLocal: boolean;
+    isValid: any;
+};
+export declare const getValidImport: (props: TamaguiOptionsWithFileInfo, moduleName: string, componentName?: string) => {
+    staticConfig: import("@tamagui/core-node").StaticConfigParsed;
+} | null;
+export declare const isValidImport: (props: TamaguiOptionsWithFileInfo, moduleName: string, componentName?: string) => any;
 //# sourceMappingURL=extractHelpers.d.ts.map

package/types/extractor/extractMediaStyle.d.ts

@@ -1,10 +1,10 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
 import { TamaguiInternalConfig } from '@tamagui/core-node';
-import { StyleObject, Ternary } from '../types';
-export declare function extractMediaStyle(ternary: Ternary, jsxPath: NodePath<t.JSXElement>, tamaguiConfig: TamaguiInternalConfig, sourcePath: string, importance?: number, shouldPrintDebug?: boolean | 'verbose'): {
+import type { TamaguiOptionsWithFileInfo, Ternary } from '../types.js';
+export declare function extractMediaStyle(props: TamaguiOptionsWithFileInfo, ternary: Ternary, jsxPath: NodePath<t.JSXElement>, tamaguiConfig: TamaguiInternalConfig, sourcePath: string, importance?: number, shouldPrintDebug?: boolean | 'verbose'): {
     mediaStyles: StyleObject[];
     ternaryWithoutMedia: Ternary | null;
 } | null;
-export declare function isValidMediaCall(jsxPath: NodePath<t.JSXElement>, init: t.Expression, sourcePath: string): boolean;
+export declare function isValidMediaCall(props: TamaguiOptionsWithFileInfo, jsxPath: NodePath<t.JSXElement>, init: t.Expression, sourcePath: string): boolean;
 //# sourceMappingURL=extractMediaStyle.d.ts.map

package/types/extractor/extractToClassNames.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import * as t from '@babel/types';
-import { TamaguiOptions } from '../types';
-import { Extractor } from './createExtractor';
+import type { TamaguiOptions } from '../types.js';
+import { Extractor } from './createExtractor.js';
 export declare type ExtractedResponse = {
     js: string | Buffer;
     styles: string;
@@ -9,11 +9,12 @@ export declare type ExtractedResponse = {
     ast: t.File;
     map: any;
 };
-export declare function extractToClassNames({ extractor, source, sourcePath, options, shouldPrintDebug, }: {
+export declare type ExtractToClassNamesProps = {
     extractor: Extractor;
     source: string | Buffer;
     sourcePath: string;
     options: TamaguiOptions;
     shouldPrintDebug: boolean | 'verbose';
-}): ExtractedResponse | null;
+};
+export declare function extractToClassNames({ extractor, source, sourcePath, options, shouldPrintDebug, }: ExtractToClassNamesProps): Promise<ExtractedResponse | null>;
 //# sourceMappingURL=extractToClassNames.d.ts.map

package/types/extractor/findTopmostFunction.d.ts

@@ -0,0 +1,4 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function findTopmostFunction(jsxPath: NodePath<t.JSXElement>): NodePath<any> | null;
+//# sourceMappingURL=findTopmostFunction.d.ts.map

package/types/extractor/generatedUid.d.ts

@@ -0,0 +1,5 @@
+declare module '@babel/types' {
+    function toIdentifier(input: string): string;
+}
+export declare function generateUid(scope: any, name: string): string;
+//# sourceMappingURL=generatedUid.d.ts.map

package/types/extractor/getPrefixLogs.d.ts

@@ -1,3 +1,3 @@
-import { TamaguiOptions } from '../types';
+import { TamaguiOptions } from '../types.js';
 export declare function getPrefixLogs(options?: TamaguiOptions): string;
 //# sourceMappingURL=getPrefixLogs.d.ts.map

package/types/extractor/getPropValueFromAttributes.d.ts

@@ -0,0 +1,19 @@
+import * as t from '@babel/types';
+/**
+ * getPropValueFromAttributes gets a prop by name from a list of attributes and accounts for potential spread operators.
+ * Here's an example. Given this component:
+ * ```
+ * <Block coolProp="wow" {...spread1} neatProp="ok" {...spread2} />```
+ * getPropValueFromAttributes will return the following:
+ * - for propName `coolProp`:
+ *   ```
+ * accessSafe(spread1, 'coolProp') || accessSafe(spread2, 'coolProp') || 'wow'```
+ * - for propName `neatProp`:
+ *   ```
+ * accessSafe(spread2, 'neatProp') || 'ok'```
+ * - for propName `notPresent`: `null`
+ *
+ * The returned value should (obviously) be placed after spread operators.
+ */
+export declare function getPropValueFromAttributes(propName: string, attrs: (t.JSXAttribute | t.JSXSpreadAttribute)[]): t.Expression | null;
+//# sourceMappingURL=getPropValueFromAttributes.d.ts.map

package/types/extractor/getSourceModule.d.ts

@@ -0,0 +1,16 @@
+import * as t from '@babel/types';
+export interface SourceModule {
+    sourceModule?: string;
+    imported?: string;
+    local?: string;
+    destructured?: boolean;
+    usesImportSyntax: boolean;
+}
+export declare function getSourceModule(itemName: string, itemBinding: {
+    constant?: boolean;
+    path: {
+        node: t.Node;
+        parent: any;
+    };
+}): SourceModule | null;
+//# sourceMappingURL=getSourceModule.d.ts.map

package/types/extractor/getStaticBindingsForScope.d.ts

@@ -0,0 +1,5 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function cleanupBeforeExit(): void;
+export declare function getStaticBindingsForScope(scope: NodePath<t.JSXElement>['scope'], whitelist: string[] | undefined, sourcePath: string, bindingCache: Record<string, string | null>, shouldPrintDebug: boolean | 'verbose'): Promise<Record<string, any>>;
+//# sourceMappingURL=getStaticBindingsForScope.d.ts.map

package/types/extractor/hoistClassNames.d.ts

@@ -0,0 +1,6 @@
+import { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function hoistClassNames(path: NodePath<t.JSXElement>, existing: {
+    [key: string]: t.Identifier;
+}, expr: t.Expression): any;
+//# sourceMappingURL=hoistClassNames.d.ts.map

package/types/extractor/literalToAst.d.ts

@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+export declare function literalToAst(literal: any): t.Expression;
+export declare function astToLiteral(node: any): any;
+//# sourceMappingURL=literalToAst.d.ts.map

package/types/extractor/loadFile.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=loadFile.d.ts.map

package/types/extractor/loadTamagui.d.ts

@@ -1,15 +1,25 @@
-import type { TamaguiComponent, TamaguiInternalConfig } from '@tamagui/core';
+import type { StaticConfigParsed, TamaguiInternalConfig } from '@tamagui/core-node';
 declare type NameToPaths = {
     [key: string]: Set<string>;
 };
+export declare type LoadedComponents = {
+    moduleName: string;
+    nameToInfo: Record<string, {
+        staticConfig: StaticConfigParsed;
+    }>;
+};
 export declare type TamaguiProjectInfo = {
-    components: Record<string, TamaguiComponent>;
+    components: LoadedComponents[];
     tamaguiConfig: TamaguiInternalConfig;
     nameToPaths: NameToPaths;
 };
-export declare function loadTamagui(props: {
+declare type Props = {
     components: string[];
-    config: string;
-}): TamaguiProjectInfo;
+    config?: string;
+    forceExports?: boolean;
+};
+export declare function loadTamagui(props: Props): Promise<TamaguiProjectInfo>;
+export declare function resolveWebOrNativeSpecificEntry(entry: string): string;
+export declare function loadTamaguiSync(props: Props): TamaguiProjectInfo;
 export {};
 //# sourceMappingURL=loadTamagui.d.ts.map

package/types/extractor/logLines.d.ts

@@ -0,0 +1,2 @@
+export declare const logLines: (str: string, singleLine?: boolean) => string;
+//# sourceMappingURL=logLines.d.ts.map

package/types/extractor/normalizeTernaries.d.ts

@@ -1,3 +1,3 @@
-import { Ternary } from '../types';
+import { Ternary } from '../types.js';
 export declare function normalizeTernaries(ternaries: Ternary[]): Ternary[];
 //# sourceMappingURL=normalizeTernaries.d.ts.map

package/types/extractor/removeUnusedHooks.d.ts

@@ -0,0 +1,3 @@
+import { NodePath } from '@babel/traverse';
+export declare function removeUnusedHooks(compFn: NodePath<any>, shouldPrintDebug: boolean | 'verbose'): void;
+//# sourceMappingURL=removeUnusedHooks.d.ts.map

package/types/extractor/timer.d.ts

@@ -0,0 +1,5 @@
+export declare const timer: () => {
+    mark: (name: string, print?: boolean) => void;
+    done: (print?: boolean) => void;
+};
+//# sourceMappingURL=timer.d.ts.map