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

package/src/extractor/getStaticBindingsForScope.ts

@@ -1,11 +1,11 @@
-import { dirname, extname, resolve } from 'path'
+import { fork } from 'child_process'
+import { dirname, extname, join, resolve } from 'path'
 
 import { Binding, NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
-import { existsSync } from 'fs-extra'
 
-import { evaluateAstNode } from './evaluateAstNode'
-import { getSourceModule } from './getSourceModule'
+import { evaluateAstNode } from './evaluateAstNode.js'
+import { getSourceModule } from './getSourceModule.js'
 
 const isLocalImport = (path: string) => path.startsWith('.') || path.startsWith('/')
 
@@ -20,40 +20,78 @@ function resolveImportPath(sourcePath: string, path: string) {
   return path
 }
 
+const cache = new Map()
+const pending = new Map<string, Promise<any>>()
+setInterval(() => {
+  if (cache.size) {
+    cache.clear()
+  }
+}, 10)
+
+const loadCmd = `${join(__dirname, 'loadFile.js')}`
+
+let exited = false
+const child = fork(loadCmd, [], {
+  execArgv: ['-r', 'esbuild-register'],
+  detached: true,
+  stdio: 'ignore',
+})
+
+export function cleanupBeforeExit() {
+  if (exited) return
+  child.removeAllListeners()
+  child.unref()
+  child.disconnect()
+  child.kill()
+  exited = true
+}
+
+process.once('SIGTERM', cleanupBeforeExit)
+process.once('SIGINT', cleanupBeforeExit)
+process.once('beforeExit', cleanupBeforeExit)
+
 function importModule(path: string) {
-  const filenames = [path.replace('.js', '.tsx'), path.replace('.js', '.ts'), path]
-  for (const file of filenames) {
-    if (existsSync(file)) {
-      const { unregister } = require('esbuild-register/dist/node').register({
-        target: 'es2019',
-        format: 'cjs',
-      })
-      try {
-        // TODO we can clear this when we see updates on it later on
-        return require(file)
-      } catch {
-        // doesn't exists
-      } finally {
-        unregister()
+  if (pending.has(path)) {
+    return pending.get(path)
+  }
+  const promise = new Promise((res, rej) => {
+    if (cache.has(path)) {
+      return cache.get(path)
+    }
+    const listener = (msg: any) => {
+      if (!msg) return
+      if (typeof msg !== 'string') return
+      if (msg[0] === '-') {
+        rej(new Error(msg.slice(1)))
+        return
       }
+      child.removeListener('message', listener)
+      const val = JSON.parse(msg)
+      cache.set(path, val)
+      res(val)
     }
-  }
-  return null
+    child.once('message', listener)
+    child.send(`${path.replace('.js', '')}`)
+  })
+  pending.set(path, promise)
+  return promise
 }
 
-export function getStaticBindingsForScope(
+export async function getStaticBindingsForScope(
   scope: NodePath<t.JSXElement>['scope'],
   whitelist: string[] = [],
   sourcePath: string,
   bindingCache: Record<string, string | null>,
   shouldPrintDebug: boolean | 'verbose'
-): Record<string, any> {
+): Promise<Record<string, any>> {
   const bindings: Record<string, Binding> = scope.getAllBindings() as any
   const ret: Record<string, any> = {}
 
-  if (shouldPrintDebug) {
+  if (
+    shouldPrintDebug
+  ) {
     // prettier-ignore
-    console.log('  ', Object.keys(bindings).length, 'variables in scope')
+    // console.log('  ', Object.keys(bindings).length, 'variables in scope')
     // .map(x => bindings[x].identifier?.name).join(', ')
   }
 
@@ -70,21 +108,33 @@ export function getStaticBindingsForScope(
       const moduleName = resolveImportPath(sourcePath, importPath)
       const isOnWhitelist = whitelist.some((test) => moduleName.endsWith(test))
       if (!isOnWhitelist) continue
-      const src = importModule(moduleName)
-      if (!src) continue
-      for (const specifier of node.specifiers) {
-        if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
-          if (typeof src[specifier.imported.name] !== 'undefined') {
-            const val = src[specifier.local.name]
-            ret[specifier.local.name] = val
+      try {
+        const src = await importModule(moduleName)
+        if (!src) continue
+        for (const specifier of node.specifiers) {
+          if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
+            if (typeof src[specifier.imported.name] !== 'undefined') {
+              const val = src[specifier.local.name]
+              ret[specifier.local.name] = val
+            }
           }
         }
+      } catch (err: any) {
+        if (shouldPrintDebug) {
+          // eslint-disable-next-line no-console
+          console.warn(
+            `    | Skipping partial evaluation of constant file: ${moduleName} (DEBUG=tamagui for more)`
+          )
+        } else if (process.env.DEBUG?.startsWith('tamagui')) {
+          // eslint-disable-next-line no-console
+          console.log(`Error in partial evaluation`, err.message, err.stack)
+        }
       }
     }
   }
 
   if (!bindingCache) {
-    throw new Error('bindingCache is a required param')
+    throw new Error('BindingCache is a required param')
   }
 
   for (const k in bindings) {
@@ -105,8 +155,9 @@ export function getStaticBindingsForScope(
       if (isOnWhitelist) {
         const src = importModule(moduleName)
         if (!src) {
+          // eslint-disable-next-line no-console
           console.log(
-            `⚠️ missing file ${moduleName} via ${sourcePath} import ${sourceModule.sourceModule}?`
+            `    | ⚠️ Missing file ${moduleName} via ${sourcePath} import ${sourceModule.sourceModule}?`
           )
           return {}
         }
@@ -115,19 +166,13 @@ export function getStaticBindingsForScope(
             ret[k] = src[sourceModule.imported]
           }
         } else {
-          // crude esmodule check
-          // TODO: make sure this actually works
-          // if (src && src.__esModule) {
-          //   ret[k] = src.default
-          // } else {
           ret[k] = src
-          // }
         }
       }
       continue
     }
 
-    const { parent, parentPath } = binding.path
+    const { parent } = binding.path
 
     if (!t.isVariableDeclaration(parent) || parent.kind !== 'const') {
       continue
@@ -144,11 +189,13 @@ export function getStaticBindingsForScope(
 
     // missing start/end will break caching
     if (typeof dec.id.start !== 'number' || typeof dec.id.end !== 'number') {
+      // eslint-disable-next-line no-console
       console.error('dec.id.start/end is not a number')
       continue
     }
 
     if (!t.isIdentifier(dec.id)) {
+      // eslint-disable-next-line no-console
       console.error('dec is not an identifier')
       continue
     }
@@ -156,12 +203,12 @@ export function getStaticBindingsForScope(
     const cacheKey = `${dec.id.name}_${dec.id.start}-${dec.id.end}`
 
     // retrieve value from cache
-    if (bindingCache.hasOwnProperty(cacheKey)) {
+    if (Object.hasOwnProperty.call(bindingCache, cacheKey)) {
       ret[k] = bindingCache[cacheKey]
       continue
     }
     // retrieve value from cache
-    if (bindingCache.hasOwnProperty(cacheKey)) {
+    if (Object.hasOwnProperty.call(bindingCache, cacheKey)) {
       ret[k] = bindingCache[cacheKey]
       continue
     }
@@ -171,11 +218,8 @@ export function getStaticBindingsForScope(
       ret[k] = evaluateAstNode(dec.init, undefined, shouldPrintDebug)
       bindingCache[cacheKey] = ret[k]
       continue
-    } catch (e) {
+    } catch {
       // skip
-      // if (shouldPrintDebug) {
-      //   console.error('[🐇] cant eval, skipping', cacheKey) //, e.message)
-      // }
     }
   }
 

package/src/extractor/loadFile.ts

@@ -0,0 +1,17 @@
+process.on('message', (path) => {
+  if (typeof path !== 'string') {
+    throw new Error(`Not a string: ${path}`)
+  }
+  try {
+    const out = require(path)
+    process.send?.(JSON.stringify(out))
+  } catch (err) {
+    if (err instanceof Error) {
+      process.send?.(`-${err.message}\n${err.stack}`)
+    } else {
+      process.send?.(`-${err}`)
+    }
+  }
+})
+
+setInterval(() => {}, 1000)