@tamagui/static 1.0.1-beta.21 → 1.0.1-beta.210

package/src/extractor/validHTMLAttributes.ts

@@ -0,0 +1,99 @@
+export const validHTMLAttributes = {
+  autocomplete: true,
+  border: true,
+  contenteditable: true,
+  crossorigin: true,
+  dir: true,
+  draggable: true,
+  enctype: true,
+  formenctype: true,
+  formmethod: true,
+  formtarget: true,
+  inputmode: true,
+  kind: true,
+  link: true,
+  method: true,
+  preload: true,
+  referrerpolicy: true,
+  rel: true,
+  rev: true,
+  role: true,
+  sandbox: true,
+  shape: true,
+  spellcheck: true,
+  target: true,
+  translate: true,
+  type: true,
+  wrap: true,
+  'aria-autocomplete': true,
+  'aria-busy': true,
+  'aria-checked': true,
+  'aria-current': true,
+  'aria-disabled': true,
+  'aria-expanded': true,
+  'aria-haspopup': true,
+  'aria-hidden': true,
+  'aria-invalid': true,
+  'aria-polite': true,
+  'aria-modal': true,
+  'aria-multiline': true,
+  'aria-multiselectable': true,
+  'aria-orientation': true,
+  'aria-pressed': true,
+  'aria-readonly': true,
+  'aria-relevant': true,
+  'aria-required': true,
+  'aria-selected': true,
+  'aria-sort': true,
+}
+
+// for moving off react-native-web eventually (unused atm)
+export const validAccessibilityAttributes = {
+  accessibilityRole: true,
+  accessibilityActiveDescendant: true,
+  accessibilityAtomic: true,
+  accessibilityAutoComplete: true,
+  accessibilityBusy: true,
+  accessibilityChecked: true,
+  accessibilityColumnCount: true,
+  accessibilityColumnIndex: true,
+  accessibilityColumnSpan: true,
+  accessibilityControls: true,
+  accessibilityCurrent: true,
+  accessibilityDescribedBy: true,
+  accessibilityDetails: true,
+  disabled: true,
+  accessibilityErrorMessage: true,
+  accessibilityExpanded: true,
+  accessibilityFlowTo: true,
+  accessibilityHasPopup: true,
+  accessibilityHidden: true,
+  accessibilityInvalid: true,
+  accessibilityKeyShortcuts: true,
+  accessibilityLabel: true,
+  accessibilityLabelledBy: true,
+  accessibilityLevel: true,
+  accessibilityLiveRegion: true,
+  accessibilityModal: true,
+  accessibilityMultiline: true,
+  accessibilityMultiSelectable: true,
+  accessibilityOrientation: true,
+  accessibilityOwns: true,
+  accessibilityPlaceholder: true,
+  accessibilityPosInSet: true,
+  accessibilityPressed: true,
+  accessibilityReadOnly: true,
+  accessibilityRequired: true,
+  accessibilityRoleDescription: true,
+  accessibilityRowCount: true,
+  accessibilityRowIndex: true,
+  accessibilityRowSpan: true,
+  accessibilitySelected: true,
+  accessibilitySetSize: true,
+  accessibilitySort: true,
+  accessibilityValueMax: true,
+  accessibilityValueMin: true,
+  accessibilityValueNow: true,
+  accessibilityValueText: true,
+  nativeID: true,
+}

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

@@ -0,0 +1,11 @@
+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 './extractor/loadTamagui.js'
+export * from './require.js'
+export * from './getPragmaOptions.js'

package/src/require.ts

@@ -0,0 +1,107 @@
+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 (SHOULD_DEBUG) {
+      // eslint-disable-next-line no-console
+      console.log('tamagui:require', path)
+    }
+    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

@@ -0,0 +1,98 @@
+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'
+
+import { LoadedComponents } from './index'
+
+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 = {
+  parserProps: TamaguiOptionsWithFileInfo
+  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
+  allLoadedComponents: LoadedComponents[]
+}
+
+export type ExtractorParseProps = Omit<TamaguiOptionsWithFileInfo, 'allLoadedComponents'> & {
+  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/babelParse.d.ts

@@ -1,5 +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): any;
+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,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,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 | 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, 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,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,12 @@ 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 type ExtractToClassNamesProps = {
     extractor: Extractor;
     source: string | Buffer;
     sourcePath: string;
     options: TamaguiOptions;
     shouldPrintDebug: boolean | 'verbose';
-    cssPath: string;
-    threaded?: boolean;
-}): ExtractedResponse | null;
+};
+export declare function extractToClassNames({ extractor, source, sourcePath, options, shouldPrintDebug, }: ExtractToClassNamesProps): Promise<ExtractedResponse | null>;
 //# sourceMappingURL=extractToClassNames.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