@tamagui/static 1.0.1-beta.19 → 1.0.1-beta.191

package/src/index.ts

@@ -0,0 +1,12 @@
+process.env.TAMAGUI_COMPILE_PROCESS = '1'
+
+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 '@tamagui/patch-rnw'
+export * from './extractor/loadTamagui.js'
+export * from './require.js'
+export * from './getPragmaOptions.js'

package/src/require.ts

@@ -0,0 +1,112 @@
+import { 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
+
+// just for catching egregious amounts of errors in a tight loop
+let tries = 0
+setInterval(() => {
+  tries = 0
+}, 50)
+
+export function registerRequire(bubbleErrors?: boolean) {
+  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 (SHOULD_DEBUG) {
+      // eslint-disable-next-line no-console
+      console.log('tamagui:require', path)
+    }
+    if (path.endsWith('.css') || path.endsWith('.json') || path.endsWith('.ttf')) {
+      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) {
+      if (bubbleErrors) {
+        throw err
+      }
+
+      // eslint-disable-next-line no-console
+      console.error(
+        `Tamagui failed requiring ${path} from your tamagui.config.ts file, ignoring\n`,
+        err.message,
+        err.stack
+      )
+      const max = process.env.TAMAGUI_MAX_ERRORS ? +process.env.TAMAGUI_MAX_ERRORS : 200
+      if (++tries > max) {
+        // eslint-disable-next-line no-console
+        console.log(
+          `Too many errors loading design system, exiting (set TAMAGUI_MAX_ERRORS to override)..`
+        )
+        // avoid infinite loops
+        process.exit(1)
+      }
+      // return proxyWorm by default
+      return proxyWorm
+    }
+  }
+
+  return Module.prototype.require
+}
+
+export function unregisterRequire() {
+  Module.prototype.require = og
+}

package/src/types.ts

@@ -0,0 +1,94 @@
+import type { NodePath } from '@babel/traverse'
+import * as t from '@babel/types'
+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'
+
+export type { TamaguiOptions } from '@tamagui/helpers-node'
+
+export type { StyleObject } from '@tamagui/helpers'
+
+export type ClassNameObject = t.StringLiteral | t.Expression
+
+export interface CacheObject {
+  [key: string]: any
+}
+
+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 = {
+  type: 'attr'
+  value: t.JSXAttribute | t.JSXSpreadAttribute
+}
+
+export type ExtractedAttrStyle = {
+  type: 'style'
+  value: ViewStyle & PseudoStyles
+  attr?: t.JSXAttribute | t.JSXSpreadAttribute
+  name?: string
+}
+
+export type ExtractedAttr =
+  | ExtractedAttrAttr
+  | { type: 'ternary'; value: Ternary }
+  | ExtractedAttrStyle
+
+export type ExtractTagProps = {
+  attrs: ExtractedAttr[]
+  node: t.JSXOpeningElement
+  attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any
+  jsxPath: NodePath<t.JSXElement>
+  programPath: NodePath<t.Program>
+  originalNodeName: string
+  lineNumbers: string
+  filePath: string
+  isFlattened: boolean
+  completeProps: Record<string, any>
+  staticConfig: StaticConfig
+}
+
+export type TamaguiOptionsWithFileInfo = TamaguiOptions & {
+  sourcePath: string
+}
+
+export type ExtractorParseProps = TamaguiOptionsWithFileInfo & {
+  target: 'native' | 'html'
+  shouldPrintDebug?: boolean | 'verbose'
+  onExtractTag: (props: ExtractTagProps) => void
+  getFlattenedNode?: (props: { isTextView: boolean; tag: string }) => string
+  extractStyledDefinitions?: boolean
+  // identifer, rule
+  onStyleRule?: (identifier: string, rules: string[]) => void
+}
+
+export interface Ternary {
+  test: t.Expression
+  // shorthand props that don't use hooks
+  inlineMediaQuery?: string
+  remove: Function
+  consequent: Object | null
+  alternate: Object | null
+}
+
+export type ClassNameToStyleObj = {
+  [key: string]: StyleObject
+}
+
+export interface PluginContext {
+  write: (path: string, rules: { [key: string]: string }) => any
+}

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

@@ -2,5 +2,5 @@ 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 CONCAT_CLASSNAME_IMPORT = "concatClassName";
+export declare const SHOULD_DEBUG: boolean | undefined;
 //# sourceMappingURL=constants.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/createEvaluator.d.ts

@@ -1,11 +1,11 @@
 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>;
+    traversePath?: NodePath<t.JSXElement>;
     shouldPrintDebug: boolean | 'verbose';
 }): (n: t.Node) => any;
 export declare function createSafeEvaluator(attemptEval: (n: t.Node) => any): (n: t.Node) => any;

package/types/extractor/createExtractor.d.ts

@@ -1,29 +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;
         };
-    }, {
-        [key: string]: import("@tamagui/core-node").GenericFont<string | number>;
-    }>;
-    parse: (fileOrPath: NodePath<t.Program> | t.File, { config, importsWhitelist, evaluateVars, shouldPrintDebug, sourcePath, onExtractTag, getFlattenedNode, disable, disableExtraction, disableExtractInlineMedia, disableExtractVariables, disableDebugAttr, prefixLogs, excludeProps, ...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/extractHelpers.d.ts

@@ -1,12 +1,14 @@
 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 | undefined) => string | t.JSXIdentifier;
+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, srcName: string) => boolean;
+export declare const isComponentPackage: (props: TamaguiOptionsWithFileInfo, srcName: string) => boolean;
+export declare const isValidImport: (props: TamaguiOptionsWithFileInfo, srcName: string) => boolean;
 //# 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,8 +1,7 @@
 /// <reference types="node" />
 import * as t from '@babel/types';
-import { LoaderContext } from 'webpack';
-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;
@@ -10,15 +9,11 @@ export declare type ExtractedResponse = {
     ast: t.File;
     map: any;
 };
-export declare function extractToClassNames({ loader, extractor, source, sourcePath, options, shouldPrintDebug, cssLoaderPath, threaded, cssPath, }: {
-    loader: LoaderContext<any>;
-    cssLoaderPath: string;
+export declare function extractToClassNames({ extractor, source, sourcePath, options, shouldPrintDebug, }: {
     extractor: Extractor;
     source: string | Buffer;
     sourcePath: string;
     options: TamaguiOptions;
     shouldPrintDebug: boolean | 'verbose';
-    cssPath: string;
-    threaded?: boolean;
-}): ExtractedResponse | null;
+}): Promise<ExtractedResponse | null>;
 //# sourceMappingURL=extractToClassNames.d.ts.map

package/types/extractor/findTopmostFunction.d.ts

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

@@ -1,3 +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/getStaticBindingsForScope.d.ts

@@ -1,4 +1,5 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-export declare function getStaticBindingsForScope(scope: NodePath<t.JSXElement>['scope'], whitelist: string[] | undefined, sourcePath: string, bindingCache: Record<string, string | null>, shouldPrintDebug: boolean | 'verbose'): Record<string, any>;
+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/loadFile.d.ts

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

package/types/extractor/loadTamagui.d.ts

@@ -1,9 +1,19 @@
-import type { TamaguiComponent, TamaguiInternalConfig } from '@tamagui/core';
-export declare function loadTamagui(props: {
-    components: string[];
-    config: string;
-}): {
+import type { TamaguiComponent, TamaguiInternalConfig } from '@tamagui/core-node';
+declare type NameToPaths = {
+    [key: string]: Set<string>;
+};
+export declare type TamaguiProjectInfo = {
     components: Record<string, TamaguiComponent>;
     tamaguiConfig: TamaguiInternalConfig;
+    nameToPaths: NameToPaths;
+};
+declare type Props = {
+    components: string[];
+    config?: string;
+    forceExports?: boolean;
+    bubbleErrors?: boolean;
 };
+export declare function loadTamagui(props: Props): Promise<TamaguiProjectInfo>;
+export declare function loadTamaguiSync(props: Props): TamaguiProjectInfo;
+export {};
 //# sourceMappingURL=loadTamagui.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/validHTMLAttributes.d.ts

@@ -46,4 +46,53 @@ export declare const validHTMLAttributes: {
     'aria-selected': boolean;
     'aria-sort': boolean;
 };
+export declare const validAccessibilityAttributes: {
+    accessibilityRole: boolean;
+    accessibilityActiveDescendant: boolean;
+    accessibilityAtomic: boolean;
+    accessibilityAutoComplete: boolean;
+    accessibilityBusy: boolean;
+    accessibilityChecked: boolean;
+    accessibilityColumnCount: boolean;
+    accessibilityColumnIndex: boolean;
+    accessibilityColumnSpan: boolean;
+    accessibilityControls: boolean;
+    accessibilityCurrent: boolean;
+    accessibilityDescribedBy: boolean;
+    accessibilityDetails: boolean;
+    disabled: boolean;
+    accessibilityErrorMessage: boolean;
+    accessibilityExpanded: boolean;
+    accessibilityFlowTo: boolean;
+    accessibilityHasPopup: boolean;
+    accessibilityHidden: boolean;
+    accessibilityInvalid: boolean;
+    accessibilityKeyShortcuts: boolean;
+    accessibilityLabel: boolean;
+    accessibilityLabelledBy: boolean;
+    accessibilityLevel: boolean;
+    accessibilityLiveRegion: boolean;
+    accessibilityModal: boolean;
+    accessibilityMultiline: boolean;
+    accessibilityMultiSelectable: boolean;
+    accessibilityOrientation: boolean;
+    accessibilityOwns: boolean;
+    accessibilityPlaceholder: boolean;
+    accessibilityPosInSet: boolean;
+    accessibilityPressed: boolean;
+    accessibilityReadOnly: boolean;
+    accessibilityRequired: boolean;
+    accessibilityRoleDescription: boolean;
+    accessibilityRowCount: boolean;
+    accessibilityRowIndex: boolean;
+    accessibilityRowSpan: boolean;
+    accessibilitySelected: boolean;
+    accessibilitySetSize: boolean;
+    accessibilitySort: boolean;
+    accessibilityValueMax: boolean;
+    accessibilityValueMin: boolean;
+    accessibilityValueNow: boolean;
+    accessibilityValueText: boolean;
+    nativeID: boolean;
+};
 //# sourceMappingURL=validHTMLAttributes.d.ts.map

package/types/getPragmaOptions.d.ts

@@ -0,0 +1,9 @@
+export declare function getPragmaOptions({ source, path, disableCommentCheck, }: {
+    source: string;
+    path: string;
+    disableCommentCheck?: boolean;
+}): {
+    shouldPrintDebug: boolean | "verbose";
+    shouldDisable: boolean;
+};
+//# sourceMappingURL=getPragmaOptions.d.ts.map

package/types/index.d.ts

@@ -1,8 +1,11 @@
-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 './patchReactNativeWeb';
+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 '@tamagui/patch-rnw';
+export * from './extractor/loadTamagui.js';
+export * from './require.js';
+export * from './getPragmaOptions.js';
 //# sourceMappingURL=index.d.ts.map

package/types/require.d.ts

@@ -0,0 +1,4 @@
+export declare const getNameToPaths: () => {};
+export declare function registerRequire(bubbleErrors?: boolean): any;
+export declare function unregisterRequire(): void;
+//# sourceMappingURL=require.d.ts.map

package/types/types.d.ts

@@ -1,31 +1,28 @@
-import { NodePath } from '@babel/traverse';
+import type { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import { PseudoStyles } 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';
+export type { TamaguiOptions } from '@tamagui/helpers-node';
+export type { StyleObject } from '@tamagui/helpers';
 export declare type ClassNameObject = t.StringLiteral | t.Expression;
 export interface CacheObject {
     [key: string]: any;
 }
-export interface TamaguiOptions {
-    components: string[];
-    config?: string;
-    evaluateVars?: boolean;
-    importsWhitelist?: string[];
-    disable?: boolean;
-    disableExtraction?: boolean;
-    disableDebugAttr?: boolean;
-    disableExtractInlineMedia?: boolean;
-    disableExtractVariables?: boolean;
-    excludeReactNativeWebExports?: string[];
-    exclude?: RegExp;
-    logTimings?: boolean;
-    prefixLogs?: string;
-    cssPath?: string;
-    cssData?: any;
-    deoptProps?: Set<string>;
-    excludeProps?: Set<string>;
-    inlineProps?: Set<string>;
+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 declare type ExtractorOptions = {
+    logger?: Logger;
+};
 export declare type ExtractedAttrAttr = {
     type: 'attr';
     value: t.JSXAttribute | t.JSXSpreadAttribute;
@@ -50,15 +47,22 @@ export declare type ExtractTagProps = {
     lineNumbers: string;
     filePath: string;
     isFlattened: boolean;
+    completeProps: Record<string, any>;
+    staticConfig: StaticConfig;
 };
-export declare type ExtractorParseProps = TamaguiOptions & {
-    sourcePath?: string;
+export declare type TamaguiOptionsWithFileInfo = TamaguiOptions & {
+    sourcePath: string;
+};
+export declare type ExtractorParseProps = TamaguiOptionsWithFileInfo & {
+    target: 'native' | 'html';
     shouldPrintDebug?: boolean | 'verbose';
     onExtractTag: (props: ExtractTagProps) => void;
-    getFlattenedNode: (props: {
+    getFlattenedNode?: (props: {
         isTextView: boolean;
         tag: string;
     }) => string;
+    extractStyledDefinitions?: boolean;
+    onStyleRule?: (identifier: string, rules: string[]) => void;
 };
 export interface Ternary {
     test: t.Expression;
@@ -67,13 +71,6 @@ export interface Ternary {
     consequent: Object | null;
     alternate: Object | null;
 }
-export declare type StyleObject = {
-    property: string;
-    value: string;
-    className: string;
-    identifier: string;
-    rules: string[];
-};
 export declare type ClassNameToStyleObj = {
     [key: string]: StyleObject;
 };

package/types/webpackPlugin.d.ts

@@ -0,0 +1,4 @@
+export declare class TamaguiWebpackPlugin {
+    apply(compiler: any): void;
+}
+//# sourceMappingURL=webpackPlugin.d.ts.map