@hanzogui/static 2.0.0

package/src/extractor/concatClassName.ts

@@ -0,0 +1,105 @@
+// perf sensitive so doing some weird stuff
+
+/**
+ * next - take objects:
+ *
+ * { _shorthand: 'postfix' }
+ *
+ */
+
+export function concatClassName(...args: any[]): any
+export function concatClassName(_cn: Record<string, any> | null | undefined): string {
+  const args = arguments
+  const usedPrefixes = new Set<string>()
+  let final = ''
+
+  const len = args.length
+  let propObjects: any = null
+  for (let x = len; x >= 0; x--) {
+    const cns = args[x]
+
+    if (!cns) continue
+    if (!Array.isArray(cns) && typeof cns !== 'string') {
+      // is prop object
+      propObjects = propObjects || []
+      propObjects.push(cns)
+      continue
+    }
+
+    const names = Array.isArray(cns) ? cns : cns.split(' ')
+    const numNames = names.length
+    for (let i = numNames - 1; i >= 0; i--) {
+      const name = names[i]
+
+      if (!name || name === ' ') continue
+      if (name[0] !== '_') {
+        // not snack style (todo slightly stronger heuristic)
+        final = name + ' ' + final
+        continue
+      }
+
+      const splitIndex = name.indexOf('-')
+      if (splitIndex < 1) {
+        final = name + ' ' + final
+        // if (shouldDebug) console.log('debug exclude:', name, final)
+        continue
+      }
+
+      const nextChar = name[splitIndex + 1]
+      // synced to static-ui constants
+      // MEDIA_SEP
+      const isMediaQuery = nextChar === '_'
+      // PSEUDO_SEP
+      // commenting out three things to make pseudos override properly
+      // (leave in for a bit to see if other bugs pop up later):
+      // 1. const isPseudoQuery = nextChar === '0'
+      const styleKey = name.slice(1, name.indexOf('-'))
+      // 2. isMediaQuery || isPseudoQuery
+      // extract just the media query name (e.g., 'lg' '_pr-_lg_260px')
+      // by finding the underscore after the media key name
+      const mediaStart = splitIndex + 2
+      const mediaEnd = name.indexOf('_', mediaStart)
+      const mediaKey =
+        isMediaQuery && mediaEnd > mediaStart ? name.slice(mediaStart, mediaEnd) : null
+      const uid = mediaKey ? styleKey + mediaKey : styleKey
+      // 3. && !isPseudoQuery
+
+      if (usedPrefixes.has(uid)) {
+        // if (shouldDebug) console.log('debug exclude:', usedPrefixes, name)
+        continue
+      }
+      usedPrefixes.add(uid)
+
+      // overrides for full safety
+      const propName = styleKey
+      if (propName && propObjects) {
+        if (
+          propObjects.some((po) => {
+            if (mediaKey) {
+              const propKey = pseudoInvert[mediaKey]
+              return po && po[propKey] && propName in po[propKey] && po[propKey] !== null
+            }
+            const res = po && propName in po && po[propName] !== null
+            return res
+          })
+        ) {
+          // if (shouldDebug) console.log('debug exclude:', name)
+          continue
+        }
+      }
+
+      final = name + ' ' + final
+    }
+  }
+
+  return final.trim()
+}
+
+const pseudoInvert = {
+  hover: 'hoverStyle',
+  focus: 'focusStyle',
+  press: 'pressStyle',
+  focusVisible: 'focusVisibleStyle',
+  focusWithin: 'focusWithinStyle',
+  disabled: 'disabledStyle',
+}

package/src/extractor/createEvaluator.ts

@@ -0,0 +1,82 @@
+import vm from 'node:vm'
+
+import generate from '@babel/generator'
+import type { NodePath } from '@babel/traverse'
+import * as t from '@babel/types'
+import esbuild from 'esbuild'
+
+import { FAILED_EVAL } from '../constants'
+import type { GuiOptionsWithFileInfo } from '../types'
+import { evaluateAstNode } from './evaluateAstNode'
+
+export function createEvaluator({
+  props,
+  staticNamespace,
+  sourcePath,
+  traversePath,
+  shouldPrintDebug,
+}: {
+  props: GuiOptionsWithFileInfo
+  staticNamespace: Record<string, any>
+  sourcePath?: string
+  traversePath?: NodePath<t.JSXElement>
+  shouldPrintDebug: boolean | 'verbose'
+}) {
+  // called when evaluateAstNode encounters a dynamic-looking prop
+  const evalFn = (n: t.Node) => {
+    // variable
+    if (t.isIdentifier(n) && typeof staticNamespace[n.name] !== 'undefined') {
+      return staticNamespace[n.name]
+    }
+
+    const evalContext = vm.createContext(staticNamespace)
+    // @ts-ignore
+    const codeWithTypescriptAnnotations = `(${generate(n as any).code})`
+    const code = esbuild
+      .transformSync(codeWithTypescriptAnnotations, { loader: 'tsx' })
+      .code.replace(/;\n$/, '')
+
+    if (shouldPrintDebug) {
+      console.info('evaluating', code)
+    }
+
+    const result1 = vm.runInContext(code, evalContext)
+    const result2 = vm.runInContext(code, evalContext)
+
+    const isDeterministic =
+      Object.is(result1, result2) ||
+      (typeof result1 === 'object' &&
+        typeof result2 === 'object' &&
+        JSON.stringify(result1) === JSON.stringify(result2))
+
+    if (!isDeterministic) {
+      if (shouldPrintDebug) {
+        console.info(
+          'Bailing on non-deterministic expression:',
+          code,
+          '\nFirst result:',
+          result1,
+          'Second result:',
+          result2
+        )
+      }
+      throw new Error(`Non-deterministic value, bailing`)
+    }
+
+    return result1
+  }
+
+  return (n: t.Node) => {
+    return evaluateAstNode(n, evalFn)
+  }
+}
+
+export function createSafeEvaluator(attemptEval: (n: t.Node) => any) {
+  return (n: t.Node) => {
+    try {
+      return attemptEval(n)
+    } catch (err) {
+      return FAILED_EVAL
+    }
+  }
+}