@tamagui/static 1.88.12 → 1.89.0-1706308641099

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/dist/esm/constants.mjs

@@ -0,0 +1,10 @@
+import findCacheDir from "find-cache-dir";
+const CSS_FILE_NAME = "__snack.css",
+  MEDIA_SEP = "_",
+  cacheDir = findCacheDir({
+    name: "tamagui",
+    create: !0
+  }),
+  FAILED_EVAL = Symbol("failed_style_eval"),
+  SHOULD_DEBUG = process.env.DEBUG === "*" || process.env.DEBUG?.startsWith("tamagui");
+export { CSS_FILE_NAME, FAILED_EVAL, MEDIA_SEP, SHOULD_DEBUG, cacheDir };

package/dist/esm/extractor/accessSafe.mjs

@@ -0,0 +1,11 @@
+import * as t from "@babel/types";
+function accessSafe(obj, member) {
+  return t.logicalExpression("&&", t.logicalExpression("&&",
+  // typeof obj === 'object
+  t.binaryExpression("===", t.unaryExpression("typeof", obj), t.stringLiteral("object")),
+  // obj !== null
+  t.binaryExpression("!==", obj, t.nullLiteral())),
+  // obj.member
+  t.memberExpression(obj, t.identifier(member), !1));
+}
+export { accessSafe };

package/dist/esm/extractor/babelParse.mjs

@@ -0,0 +1,18 @@
+import * as babelParser from "@babel/parser";
+const plugins = ["asyncGenerators", "classProperties", "dynamicImport", "functionBind", "jsx", "numericSeparator", "objectRestSpread", "optionalCatchBinding", "decorators-legacy", "typescript", "optionalChaining", "nullishCoalescingOperator"],
+  parserOptions = Object.freeze({
+    plugins,
+    sourceType: "module"
+  }),
+  parser = babelParser.parse.bind(babelParser);
+function babelParse(code, fileName) {
+  const codeString = code.toString();
+  try {
+    return parser(codeString, parserOptions);
+  } catch (err) {
+    throw new Error(`Error parsing babel: ${err} in ${fileName}, code:
+${codeString}
+ ${err.stack}`);
+  }
+}
+export { babelParse, parserOptions };

package/dist/esm/extractor/buildClassName.mjs

@@ -0,0 +1,26 @@
+import * as t from "@babel/types";
+const buildClassName = (objectsIn, extras = "") => {
+    let objects = buildClassNameLogic(objectsIn);
+    return objects ? (t.isStringLiteral(objects) ? objects.value = `${extras} ${objects.value}` : objects = t.binaryExpression("+", t.stringLiteral(extras), objects), objects) : null;
+  },
+  buildClassNameLogic = objects => objects.reduce((acc, val) => {
+    if (acc == null) return (
+      // pass conditional expressions through
+      t.isConditionalExpression(val) ||
+      // pass non-null literals through
+      t.isStringLiteral(val) || t.isNumericLiteral(val) ? val : t.logicalExpression("||", val, t.stringLiteral(""))
+    );
+    let inner;
+    if (t.isStringLiteral(val)) {
+      if (t.isStringLiteral(acc)) return t.stringLiteral(`${acc.value} ${val.value}`);
+      inner = t.stringLiteral(` ${val.value}`);
+    } else if (t.isLiteral(val)) inner = t.binaryExpression("+", t.stringLiteral(" "), val);else if (t.isConditionalExpression(val) || t.isBinaryExpression(val)) {
+      if (t.isStringLiteral(acc)) return t.binaryExpression("+", t.stringLiteral(`${acc.value} `), val);
+      inner = t.binaryExpression("+", t.stringLiteral(" "), val);
+    } else if (t.isIdentifier(val) || t.isMemberExpression(val)) inner = t.conditionalExpression(val, t.binaryExpression("+", t.stringLiteral(" "), val), t.stringLiteral(""));else {
+      if (t.isStringLiteral(acc)) return t.binaryExpression("+", t.stringLiteral(`${acc.value} `), t.logicalExpression("||", val, t.stringLiteral("")));
+      inner = t.binaryExpression("+", t.stringLiteral(" "), t.logicalExpression("||", val, t.stringLiteral("")));
+    }
+    return t.binaryExpression("+", acc, inner);
+  }, null);
+export { buildClassName, buildClassNameLogic };

package/dist/esm/extractor/bundle.mjs

@@ -0,0 +1,94 @@
+import { basename, dirname, join } from "path";
+import esbuild from "esbuild";
+import { pathExists, stat, writeFile } from "fs-extra";
+import { esbuildAliasPlugin } from "./esbuildAliasPlugin.mjs";
+import { resolveWebOrNativeSpecificEntry } from "./loadTamagui.mjs";
+function getESBuildConfig({
+  entryPoints,
+  resolvePlatformSpecificEntries,
+  ...options
+}, platform, aliases) {
+  process.env.DEBUG?.startsWith("tamagui") && console.info("Building", entryPoints);
+  const tsconfig = join(__dirname, "..", "..", "..", "tamagui.tsconfig.json");
+  return {
+    bundle: !0,
+    entryPoints: resolvePlatformSpecificEntries ? entryPoints.map(resolveWebOrNativeSpecificEntry) : entryPoints,
+    format: "cjs",
+    target: "node16",
+    jsx: "transform",
+    jsxFactory: "react",
+    allowOverwrite: !0,
+    keepNames: !0,
+    resolveExtensions: [".web.tsx", ".web.ts", ".web.jsx", ".web.js", ".tsx", ".ts", ".jsx", ".js"],
+    platform: "node",
+    tsconfig,
+    loader: {
+      ".js": "jsx",
+      ".png": "dataurl",
+      ".jpg": "dataurl",
+      ".jpeg": "dataurl",
+      ".svg": "dataurl",
+      ".gif": "dataurl",
+      ".webp": "dataurl",
+      ".woff2": "dataurl",
+      ".woff": "dataurl",
+      ".eot": "dataurl",
+      ".otf": "dataurl",
+      ".ttf": "dataurl"
+    },
+    logLevel: "warning",
+    plugins: [{
+      name: "external",
+      setup(build) {
+        build.onResolve({
+          filter: /@tamagui\/core/
+        }, args => ({
+          path: platform === "native" ? "@tamagui/core/native" : "@tamagui/core",
+          external: !0
+        })), build.onResolve({
+          filter: /react-native\/package.json$/
+        }, args => ({
+          path: "react-native/package.json",
+          external: !0
+        })), build.onResolve({
+          filter: /@tamagui\/web/
+        }, args => ({
+          path: platform === "native" ? "@tamagui/core/native" : "@tamagui/core",
+          external: !0
+        })), build.onResolve({
+          filter: /^(react-native|react-native\/.*)$/
+        }, args => ({
+          path: "react-native-web-lite",
+          external: !0
+        })), build.onResolve({
+          filter: /react-native-reanimated/
+        }, args => ({
+          path: "react-native-reanimated",
+          external: !0
+        }));
+      }
+    }, esbuildAliasPlugin({
+      ...aliases
+    })],
+    ...options
+  };
+}
+async function bundle(props, platform, aliases) {
+  await asyncLock(props);
+  const config = getESBuildConfig(props, platform, aliases);
+  return esbuild.build(config);
+}
+async function asyncLock(props) {
+  const lockFile = join(dirname(props.outfile), basename(props.outfile, ".lock")),
+    lockStat = await stat(lockFile).catch(() => {});
+  if ((lockStat ? /* @__PURE__ */new Date().getTime() - new Date(lockStat.mtime).getTime() : 1 / 0) < 500) {
+    process.env.DEBUG?.startsWith("tamagui") && console.info("Waiting for existing build", props.entryPoints);
+    let tries = 5;
+    for (; tries--;) {
+      if (await pathExists(props.outfile)) return;
+      await new Promise(res => setTimeout(res, 50));
+    }
+  }
+  writeFile(lockFile, "");
+}
+export { bundle };

package/dist/esm/extractor/bundleConfig.mjs

@@ -0,0 +1,263 @@
+import { readFileSync } from "fs";
+import { basename, dirname, extname, join, relative, sep } from "path";
+import generate from "@babel/generator";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { Color, colorLog } from "@tamagui/cli-color";
+import esbuild from "esbuild";
+import { ensureDir, removeSync, writeFileSync } from "fs-extra";
+import { registerRequire, setRequireResult } from "../registerRequire.mjs";
+import { babelParse } from "./babelParse.mjs";
+import { bundle } from "./bundle.mjs";
+import { getTamaguiConfigPathFromOptionsConfig } from "./getTamaguiConfigPathFromOptionsConfig.mjs";
+const external = ["@tamagui/core", "@tamagui/web", "react", "react-dom", "react-native-svg"],
+  esbuildExtraOptions = {
+    define: {
+      __DEV__: `${process.env.NODE_ENV === "development"}`
+    }
+  },
+  esbuildOptions = {
+    target: "es2018",
+    format: "cjs",
+    jsx: "automatic",
+    platform: "node",
+    ...esbuildExtraOptions
+  };
+let currentBundle = null,
+  isBundling = !1,
+  lastBundle = null;
+const waitForBundle = /* @__PURE__ */new Set();
+function hasBundledConfigChanged() {
+  return lastBundle === currentBundle ? !1 : (lastBundle = currentBundle, !0);
+}
+async function getBundledConfig(props, rebuild = !1) {
+  if (isBundling) await new Promise(res => {
+    waitForBundle.add(res);
+  });else if (!currentBundle || rebuild) return await bundleConfig(props);
+  return currentBundle;
+}
+async function bundleConfig(props) {
+  try {
+    isBundling = !0;
+    const configEntry = props.config ? getTamaguiConfigPathFromOptionsConfig(props.config) : "",
+      tmpDir = join(process.cwd(), ".tamagui"),
+      configOutPath = join(tmpDir, "tamagui.config.cjs"),
+      baseComponents = props.components.filter(x => x !== "@tamagui/core"),
+      componentOutPaths = baseComponents.map(componentModule => join(tmpDir, `${componentModule.split(sep).join("-").replace(/[^a-z0-9]+/gi, "")}-components.config.cjs`));
+    if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui") && console.info("Building config entry", configEntry), !props.disableInitialBuild) {
+      try {
+        await ensureDir(tmpDir);
+      } catch {}
+      const start = Date.now();
+      await Promise.all([props.config ? bundle({
+        entryPoints: [configEntry],
+        external,
+        outfile: configOutPath,
+        target: "node16",
+        ...esbuildExtraOptions
+      }, props.platform) : null, ...baseComponents.map((componentModule, i) => bundle({
+        entryPoints: [componentModule],
+        resolvePlatformSpecificEntries: !0,
+        external,
+        outfile: componentOutPaths[i],
+        target: "node16",
+        ...esbuildExtraOptions
+      }, props.platform))]), colorLog(Color.FgYellow, `
+    \u27A1 [tamagui] built config and components (${Date.now() - start}ms):`), colorLog(Color.Dim, `
+        Config     .${sep}${relative(process.cwd(), configOutPath)}
+        Components ${[...componentOutPaths.map(p => `.${sep}${relative(process.cwd(), p)}`)].join(`
+             `)}
+        `);
+    }
+    let out;
+    const {
+      unregister
+    } = registerRequire(props.platform);
+    try {
+      out = require(configOutPath);
+    } catch (err) {
+      throw err;
+    } finally {
+      unregister();
+    }
+    let config = out.default || out || out.config;
+    if (config && config.config && !config.tokens && (config = config.config), !config) throw new Error(`No config: ${config}`);
+    let components = loadComponents({
+      ...props,
+      components: componentOutPaths
+    });
+    if (!components) throw new Error(`No components found: ${componentOutPaths.join(", ")}`);
+    for (const component of components) component.moduleName = baseComponents[componentOutPaths.indexOf(component.moduleName)] || component.moduleName, component.moduleName || (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) && console.warn(`\u26A0\uFE0F no module name found: ${component.moduleName} ${JSON.stringify(baseComponents)} in ${JSON.stringify(componentOutPaths)}`);
+    process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui") && console.info("Loaded components", components);
+    const res = {
+      components,
+      nameToPaths: {},
+      tamaguiConfig: config
+    };
+    return currentBundle = res, res;
+  } catch (err) {
+    console.error(`Error bundling tamagui config: ${err?.message} (run with DEBUG=tamagui to see stack)`), process.env.DEBUG?.includes("tamagui") && console.error(err.stack);
+  } finally {
+    isBundling = !1, waitForBundle.forEach(cb => cb()), waitForBundle.clear();
+  }
+}
+function loadComponents(props, forceExports = !1) {
+  const coreComponents = getCoreComponents(props),
+    otherComponents = loadComponentsInner(props, forceExports);
+  return [...coreComponents, ...(otherComponents || [])];
+}
+function getCoreComponents(props) {
+  const loaded = loadComponentsInner({
+    ...props,
+    components: ["@tamagui/core"]
+  });
+  if (!loaded) throw new Error("Core should always load");
+  return [{
+    ...loaded[0],
+    moduleName: "@tamagui/core"
+  }];
+}
+function loadComponentsInner(props, forceExports = !1) {
+  const componentsModules = props.components,
+    key = componentsModules.join("");
+  if (!forceExports && cacheComponents[key]) return cacheComponents[key];
+  const {
+    unregister
+  } = registerRequire(props.platform, {
+    proxyWormImports: forceExports
+  });
+  try {
+    const info = componentsModules.flatMap(name => {
+      const isDynamic = !!extname(name) && forceExports,
+        fileContents = isDynamic ? readFileSync(name, "utf-8") : "",
+        loadModule = isDynamic ? join(dirname(name), `.tamagui-dynamic-eval-${basename(name)}.tsx`) : name;
+      let writtenContents = fileContents,
+        didBabel = !1;
+      function attemptLoad({
+        forceExports: forceExports2 = !1
+      } = {}) {
+        isDynamic && (writtenContents = forceExports2 ? transformAddExports(babelParse(esbuildit(fileContents, "modern"), name)) : fileContents, writeFileSync(loadModule, writtenContents), esbuild.buildSync({
+          ...esbuildOptions,
+          entryPoints: [loadModule],
+          outfile: loadModule,
+          alias: {
+            "react-native": require.resolve("react-native-web-lite")
+          },
+          bundle: !0,
+          packages: "external",
+          allowOverwrite: !0,
+          // logLevel: 'silent',
+          sourcemap: !1,
+          loader: {
+            ".png": "dataurl",
+            ".jpg": "dataurl",
+            ".jpeg": "dataurl",
+            ".gif": "dataurl"
+          }
+        })), process.env.DEBUG === "tamagui" && console.info("loadModule", loadModule, require.resolve(loadModule));
+        const moduleResult = require(loadModule);
+        forceExports2 || setRequireResult(name, moduleResult);
+        const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+        return {
+          moduleName: name,
+          nameToInfo
+        };
+      }
+      const dispose = () => {
+        isDynamic && removeSync(loadModule);
+      };
+      try {
+        const res = attemptLoad({
+          forceExports: !0
+        });
+        return didBabel = !0, res;
+      } catch (err) {
+        console.info("babel err", err, writtenContents), writtenContents = fileContents, process.env.DEBUG?.startsWith("tamagui") && console.info("Error parsing babel likely", err);
+      } finally {
+        dispose();
+      }
+      try {
+        return attemptLoad({
+          forceExports: !1
+        });
+      } catch (err) {
+        return process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && (console.info(`
+
+Tamagui attempted but failed to dynamically optimize components in:
+  ${name}
+`), console.info(err), console.info(`At: ${loadModule}`, `
+didBabel: ${didBabel}`, `
+In:`, writtenContents, `
+isDynamic: `, isDynamic)), [];
+      } finally {
+        dispose();
+      }
+    });
+    return cacheComponents[key] = info, info;
+  } catch (err) {
+    return console.info("Tamagui error bundling components", err.message, err.stack), null;
+  } finally {
+    unregister();
+  }
+}
+const esbuildit = (src, target) => esbuild.transformSync(src, {
+  ...esbuildOptions,
+  ...(target === "modern" && {
+    target: "es2022",
+    jsx: "automatic",
+    loader: "tsx",
+    platform: "neutral",
+    format: "esm"
+  })
+}).code;
+function getComponentStaticConfigByName(name, exported) {
+  const components = {};
+  try {
+    if (!exported || typeof exported != "object" || Array.isArray(exported)) throw new Error(`Invalid export from package ${name}: ${typeof exported}`);
+    for (const key in exported) {
+      const found = getTamaguiComponent(key, exported[key]);
+      if (found) {
+        const {
+          Component,
+          ...sc
+        } = found.staticConfig;
+        components[key] = {
+          staticConfig: sc
+        };
+      }
+    }
+  } catch (err) {
+    process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && (console.error(`Tamagui failed getting components from ${name} (Disable error by setting environment variable TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD=1)`), console.error(err));
+  }
+  return components;
+}
+function getTamaguiComponent(name, Component) {
+  if (name[0].toUpperCase() !== name[0]) return;
+  if (Component?.staticConfig) return Component;
+}
+function interopDefaultExport(mod) {
+  return mod?.default ?? mod;
+}
+const cacheComponents = {};
+function transformAddExports(ast) {
+  const usedNames = /* @__PURE__ */new Set();
+  return traverse(ast, {
+    ExportNamedDeclaration(nodePath) {
+      if (nodePath.node.specifiers) for (const spec of nodePath.node.specifiers) usedNames.add(t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value);
+    }
+  }), traverse(ast, {
+    VariableDeclaration(nodePath) {
+      if (!t.isProgram(nodePath.parent)) return;
+      const decs = nodePath.node.declarations;
+      if (decs.length > 1) return;
+      const [dec] = decs;
+      t.isIdentifier(dec.id) && dec.init && (usedNames.has(dec.id.name) || (usedNames.add(dec.id.name), nodePath.replaceWith(t.exportNamedDeclaration(t.variableDeclaration("let", [dec]), [t.exportSpecifier(t.identifier(dec.id.name), t.identifier(dec.id.name))]))));
+    }
+  }), generate(ast, {
+    concise: !1,
+    filename: "test.tsx",
+    retainLines: !1,
+    sourceMaps: !1
+  }).code;
+}
+export { bundleConfig, esbuildOptions, getBundledConfig, hasBundledConfigChanged, loadComponents, loadComponentsInner };

package/dist/esm/extractor/createEvaluator.mjs

@@ -0,0 +1,34 @@
+import vm from "vm";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import esbuild from "esbuild";
+import { FAILED_EVAL } from "../constants.mjs";
+import { evaluateAstNode } from "./evaluateAstNode.mjs";
+function createEvaluator({
+  props,
+  staticNamespace,
+  sourcePath,
+  traversePath,
+  shouldPrintDebug
+}) {
+  const evalFn = n => {
+    if (t.isIdentifier(n) && typeof staticNamespace[n.name] < "u") return staticNamespace[n.name];
+    const evalContext = vm.createContext(staticNamespace),
+      codeWithTypescriptAnnotations = `(${generate(n).code})`,
+      code = esbuild.transformSync(codeWithTypescriptAnnotations, {
+        loader: "tsx"
+      }).code.replace(/;\n$/, "");
+    return shouldPrintDebug && console.info("evaluating", code), vm.runInContext(code, evalContext);
+  };
+  return n => evaluateAstNode(n, evalFn);
+}
+function createSafeEvaluator(attemptEval) {
+  return n => {
+    try {
+      return attemptEval(n);
+    } catch {
+      return FAILED_EVAL;
+    }
+  };
+}
+export { createEvaluator, createSafeEvaluator };