@tamagui/static 1.0.0-alpha.11 → 1.0.0-alpha.12

package/dist/jsx/extractor/getSourceModule.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as t from "@babel/types";
+function getSourceModule(itemName, itemBinding) {
+  if (!itemBinding.constant) {
+    return null;
+  }
+  let sourceModule;
+  let imported;
+  let local;
+  let destructured;
+  let usesImportSyntax = false;
+  const itemNode = itemBinding.path.node;
+  if (t.isImportDefaultSpecifier(itemNode) || t.isImportSpecifier(itemNode)) {
+    if (t.isImportDeclaration(itemBinding.path.parent)) {
+      sourceModule = itemBinding.path.parent.source.value;
+      local = itemNode.local.name;
+      usesImportSyntax = true;
+      if (t.isImportSpecifier(itemNode)) {
+        imported = itemNode.imported["name"];
+        destructured = true;
+      } else {
+        imported = itemNode.local.name;
+        destructured = false;
+      }
+    }
+  } else if (t.isVariableDeclarator(itemNode) && itemNode.init != null && t.isCallExpression(itemNode.init) && t.isIdentifier(itemNode.init.callee) && itemNode.init.callee.name === "require" && itemNode.init.arguments.length === 1) {
+    const firstArg = itemNode.init.arguments[0];
+    if (!t.isStringLiteral(firstArg)) {
+      return null;
+    }
+    sourceModule = firstArg.value;
+    if (t.isIdentifier(itemNode.id)) {
+      local = itemNode.id.name;
+      imported = itemNode.id.name;
+      destructured = false;
+    } else if (t.isObjectPattern(itemNode.id)) {
+      for (const objProp of itemNode.id.properties) {
+        if (t.isObjectProperty(objProp) && t.isIdentifier(objProp.value) && objProp.value.name === itemName) {
+          local = objProp.value.name;
+          imported = objProp.key.name;
+          destructured = true;
+          break;
+        }
+      }
+      if (!local || !imported) {
+        console.error("could not find prop with value `%s`", itemName);
+        return null;
+      }
+    } else {
+      console.error("Unhandled id type: %s", itemNode.id.type);
+      return null;
+    }
+  } else {
+    return null;
+  }
+  return {
+    destructured,
+    imported,
+    local,
+    sourceModule,
+    usesImportSyntax
+  };
+}
+__name(getSourceModule, "getSourceModule");
+export {
+  getSourceModule
+};

package/dist/jsx/extractor/getStaticBindingsForScope.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { dirname, extname, resolve } from "path";
+import * as t from "@babel/types";
+import { existsSync } from "fs-extra";
+import { evaluateAstNode } from "./evaluateAstNode";
+import { getSourceModule } from "./getSourceModule";
+const isLocalImport = /* @__PURE__ */ __name((path) => path.startsWith(".") || path.startsWith("/"), "isLocalImport");
+function resolveImportPath(sourcePath, path) {
+  const sourceDir = dirname(sourcePath);
+  if (isLocalImport(path)) {
+    if (extname(path) === "") {
+      path += ".js";
+    }
+    return resolve(sourceDir, path);
+  }
+  return path;
+}
+__name(resolveImportPath, "resolveImportPath");
+function importModule(path) {
+  const filenames = [path.replace(".js", ".tsx"), path.replace(".js", ".ts"), path];
+  for (const file of filenames) {
+    if (existsSync(file)) {
+      return require(file);
+    }
+  }
+  return null;
+}
+__name(importModule, "importModule");
+function getStaticBindingsForScope(scope, whitelist = [], sourcePath, bindingCache, shouldPrintDebug) {
+  const bindings = scope.getAllBindings();
+  const ret = {};
+  if (shouldPrintDebug) {
+    console.log("  ", Object.keys(bindings).length, "variables in scope");
+  }
+  const program = scope.getProgramParent().block;
+  for (const node of program.body) {
+    if (t.isImportDeclaration(node)) {
+      const importPath = node.source.value;
+      if (!node.specifiers.length)
+        continue;
+      if (!isLocalImport(importPath)) {
+        continue;
+      }
+      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;
+          }
+        }
+      }
+    }
+  }
+  if (!bindingCache) {
+    throw new Error("bindingCache is a required param");
+  }
+  for (const k in bindings) {
+    const binding = bindings[k];
+    const sourceModule = getSourceModule(k, binding);
+    if (sourceModule) {
+      if (!sourceModule.sourceModule) {
+        continue;
+      }
+      const moduleName = resolveImportPath(sourcePath, sourceModule.sourceModule);
+      const isOnWhitelist = whitelist.some((test) => moduleName.endsWith(test));
+      if (isOnWhitelist) {
+        const src = importModule(moduleName);
+        if (!src) {
+          console.log(`\u26A0\uFE0F missing file ${moduleName} via ${sourcePath} import ${sourceModule.sourceModule}?`);
+          return {};
+        }
+        if (sourceModule.destructured) {
+          if (sourceModule.imported) {
+            ret[k] = src[sourceModule.imported];
+          }
+        } else {
+          ret[k] = src;
+        }
+      }
+      continue;
+    }
+    const { parent, parentPath } = binding.path;
+    if (!t.isVariableDeclaration(parent) || parent.kind !== "const") {
+      continue;
+    }
+    const dec = parent.declarations.find((d) => t.isIdentifier(d.id) && d.id.name === k);
+    if (!dec || !dec.init) {
+      continue;
+    }
+    if (typeof dec.id.start !== "number" || typeof dec.id.end !== "number") {
+      console.error("dec.id.start/end is not a number");
+      continue;
+    }
+    if (!t.isIdentifier(dec.id)) {
+      console.error("dec is not an identifier");
+      continue;
+    }
+    const cacheKey = `${dec.id.name}_${dec.id.start}-${dec.id.end}`;
+    if (bindingCache.hasOwnProperty(cacheKey)) {
+      ret[k] = bindingCache[cacheKey];
+      continue;
+    }
+    if (bindingCache.hasOwnProperty(cacheKey)) {
+      ret[k] = bindingCache[cacheKey];
+      continue;
+    }
+    try {
+      ret[k] = evaluateAstNode(dec.init, void 0, shouldPrintDebug);
+      bindingCache[cacheKey] = ret[k];
+      continue;
+    } catch (e) {
+    }
+  }
+  return ret;
+}
+__name(getStaticBindingsForScope, "getStaticBindingsForScope");
+export {
+  getStaticBindingsForScope
+};

package/dist/jsx/extractor/hoistClassNames.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as t from "@babel/types";
+function hoistClassNames(path, existing, expr) {
+  const hoist = hoistClassNames.bind(null, path, existing);
+  if (t.isStringLiteral(expr)) {
+    if (expr.value.trim() === "") {
+      return expr;
+    }
+    if (existing[expr.value]) {
+      return existing[expr.value];
+    }
+    const identifier = replaceStringWithVariable(expr);
+    existing[expr.value] = identifier;
+    return identifier;
+  }
+  if (t.isBinaryExpression(expr)) {
+    return t.binaryExpression(expr.operator, hoist(expr.left), hoist(expr.right));
+  }
+  if (t.isLogicalExpression(expr)) {
+    return t.logicalExpression(expr.operator, hoist(expr.left), hoist(expr.right));
+  }
+  if (t.isConditionalExpression(expr)) {
+    return t.conditionalExpression(expr.test, hoist(expr.consequent), hoist(expr.alternate));
+  }
+  return expr;
+  function replaceStringWithVariable(str) {
+    const uid = path.scope.generateUidIdentifier("cn");
+    const parent = path.findParent((path2) => path2.isProgram());
+    if (!parent)
+      throw new Error(`no program?`);
+    const variable = t.variableDeclaration("const", [
+      t.variableDeclarator(uid, t.stringLiteral(` ${str.value}`))
+    ]);
+    parent.unshiftContainer("body", variable);
+    return uid;
+  }
+  __name(replaceStringWithVariable, "replaceStringWithVariable");
+}
+__name(hoistClassNames, "hoistClassNames");
+export {
+  hoistClassNames
+};

package/dist/jsx/extractor/literalToAst.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as t from "@babel/types";
+function literalToAst(literal) {
+  if (literal === null) {
+    return t.nullLiteral();
+  }
+  switch (typeof literal) {
+    case "function":
+      throw new Error("Unsupported");
+    case "number":
+      return t.numericLiteral(literal);
+    case "string":
+      return t.stringLiteral(literal);
+    case "boolean":
+      return t.booleanLiteral(literal);
+    case "undefined":
+      return t.unaryExpression("void", t.numericLiteral(0), true);
+    default:
+      if (Array.isArray(literal)) {
+        return t.arrayExpression(literal.map(literalToAst));
+      }
+      return t.objectExpression(Object.keys(literal).filter((k) => {
+        return typeof literal[k] !== "undefined";
+      }).map((k) => {
+        return t.objectProperty(t.stringLiteral(k), literalToAst(literal[k]));
+      }));
+  }
+}
+__name(literalToAst, "literalToAst");
+export {
+  literalToAst
+};

package/dist/jsx/extractor/loadTamagui.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { join } from "path";
+import { createTamagui } from "@tamagui/core-node";
+let loadedTamagui = null;
+function loadTamagui(props) {
+  if (loadedTamagui) {
+    return loadedTamagui;
+  }
+  process.env.IS_STATIC = "is_static";
+  const proxyWorm = require("@tamagui/fake-react-native");
+  const Mod = require("module");
+  const og = Mod.prototype.require;
+  Mod.prototype.require = function(path) {
+    if (path.startsWith("react-native") && !path.startsWith("react-native-web/dist/cjs/exports")) {
+      return proxyWorm;
+    }
+    return og.apply(this, arguments);
+  };
+  const configPath = join(process.cwd(), props.config);
+  const tamaguiConfigExport = require(configPath);
+  const tamaguiConfig = tamaguiConfigExport["default"] || tamaguiConfigExport;
+  const components = {};
+  for (const module of props.components) {
+    const exported = require(module);
+    Object.assign(components, exported);
+  }
+  process.env.IS_STATIC = void 0;
+  Mod.prototype.require = og;
+  createTamagui(tamaguiConfig);
+  loadedTamagui = {
+    components,
+    tamaguiConfig
+  };
+  return loadedTamagui;
+}
+__name(loadTamagui, "loadTamagui");
+export {
+  loadTamagui
+};

package/dist/jsx/extractor/logLines.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const logLines = /* @__PURE__ */ __name((str) => {
+  let lines = [""];
+  const items = str.split(" ");
+  for (const item of items) {
+    if (item.length + lines[lines.length - 1].length > 100) {
+      lines.push("");
+    }
+    lines[lines.length - 1] += item + " ";
+  }
+  return lines.map((line, i) => "           " + (i == 0 ? "" : " ") + line.trim()).join("\n");
+}, "logLines");
+export {
+  logLines
+};

package/dist/jsx/extractor/normalizeTernaries.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import invariant from "invariant";
+function normalizeTernaries(ternaries) {
+  invariant(Array.isArray(ternaries), "extractStaticTernaries expects param 1 to be an array of ternaries");
+  if (ternaries.length === 0) {
+    return [];
+  }
+  const ternariesByKey = {};
+  for (let idx = -1, len = ternaries.length; ++idx < len; ) {
+    const { test, consequent, alternate, remove, ...rest } = ternaries[idx];
+    let ternaryTest = test;
+    if (t.isExpressionStatement(test)) {
+      ternaryTest = test.expression;
+    }
+    let shouldSwap = false;
+    if (t.isUnaryExpression(test) && test.operator === "!") {
+      ternaryTest = test.argument;
+      shouldSwap = true;
+    } else if (t.isBinaryExpression(test)) {
+      if (test.operator === "!==" || test.operator === "!=") {
+        ternaryTest = t.binaryExpression(test.operator, test.left, test.right);
+        shouldSwap = true;
+      }
+    }
+    const key = generate(ternaryTest).code;
+    if (!ternariesByKey[key]) {
+      ternariesByKey[key] = {
+        ...rest,
+        alternate: {},
+        consequent: {},
+        test: ternaryTest,
+        remove
+      };
+    }
+    const altStyle = (shouldSwap ? consequent : alternate) ?? {};
+    const consStyle = (shouldSwap ? alternate : consequent) ?? {};
+    Object.assign(ternariesByKey[key].alternate, altStyle);
+    Object.assign(ternariesByKey[key].consequent, consStyle);
+  }
+  const ternaryExpression = Object.keys(ternariesByKey).map((key) => {
+    return ternariesByKey[key];
+  });
+  return ternaryExpression;
+}
+__name(normalizeTernaries, "normalizeTernaries");
+export {
+  normalizeTernaries
+};

package/dist/jsx/extractor/removeUnusedHooks.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as t from "@babel/types";
+const hooks = {
+  useMedia: true,
+  useTheme: true
+};
+function removeUnusedHooks(compFn, shouldPrintDebug) {
+  compFn.scope.crawl();
+  let bodyStatements = compFn?.get("body");
+  if (!bodyStatements) {
+    console.log("no body statemnts?", compFn);
+    return;
+  }
+  if (!Array.isArray(bodyStatements)) {
+    if (bodyStatements.isFunctionExpression()) {
+      bodyStatements = bodyStatements.scope.path.get("body");
+    } else {
+      bodyStatements = bodyStatements.get("body");
+    }
+  }
+  if (!bodyStatements || !Array.isArray(bodyStatements)) {
+    return;
+  }
+  const statements = bodyStatements;
+  for (const statement of statements) {
+    if (!statement.isVariableDeclaration()) {
+      continue;
+    }
+    const declarations = statement.get("declarations");
+    if (!Array.isArray(declarations)) {
+      continue;
+    }
+    const isBindingReferenced = /* @__PURE__ */ __name((name) => {
+      return !!statement.scope.getBinding(name)?.referenced;
+    }, "isBindingReferenced");
+    for (const declarator of declarations) {
+      const id = declarator.get("id");
+      const init = declarator.node.init;
+      if (Array.isArray(id) || Array.isArray(init)) {
+        continue;
+      }
+      const shouldRemove = (() => {
+        const isHook = t.isCallExpression(init) && t.isIdentifier(init.callee) && hooks[init.callee.name];
+        if (!isHook) {
+          return false;
+        }
+        if (t.isIdentifier(id.node)) {
+          const name = id.node.name;
+          return !isBindingReferenced(name);
+        } else if (t.isObjectPattern(id.node)) {
+          const propPaths = id.get("properties");
+          return propPaths.every((prop) => {
+            if (!prop.isObjectProperty())
+              return false;
+            const value = prop.get("value");
+            if (Array.isArray(value) || !value.isIdentifier())
+              return false;
+            const name = value.node.name;
+            return !isBindingReferenced(name);
+          });
+        }
+        return false;
+      })();
+      if (shouldRemove) {
+        declarator.remove();
+        if (shouldPrintDebug) {
+          console.log(`  [\u{1FA9D}] removed ${id.node["name"] ?? ""}`);
+        }
+      }
+    }
+  }
+}
+__name(removeUnusedHooks, "removeUnusedHooks");
+export {
+  removeUnusedHooks
+};

package/dist/jsx/index.js

@@ -0,0 +1,13 @@
+process.env.TAMAGUI_COMPILE_PROCESS = "1";
+import { TamaguiOptions } from "./types";
+import { createExtractor } from "./extractor/createExtractor";
+import { literalToAst } from "./extractor/literalToAst";
+export * from "./constants";
+export * from "./extractor/extractToClassNames";
+export * from "./extractor/extractHelpers";
+export * from "./patchReactNativeWeb";
+export {
+  TamaguiOptions,
+  createExtractor,
+  literalToAst
+};

package/dist/jsx/patchReactNativeWeb.js

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import * as fs from "fs";
+import path from "path";
+function patchReactNativeWeb() {
+  const rootDir = require.resolve("react-native-web").replace(/\/dist.*/, "");
+  const modulePath = path.join(rootDir, "dist", "tamagui-exports.js");
+  const cjsPath = path.join(rootDir, "dist", "cjs", "tamagui-exports.js");
+  const isEqual = (() => {
+    let res = false;
+    try {
+      res = fs.readFileSync(modulePath, "utf-8") === moduleExports && fs.readFileSync(cjsPath, "utf-8") == cjsExports;
+    } catch {
+      res = false;
+    }
+    return res;
+  })();
+  if (!isEqual) {
+    console.log("\u{1F95A} Tamagui patching react-native-web to share atomic styling primitives");
+    console.log("   > adding", modulePath);
+    console.log("   > adding", cjsPath);
+    fs.writeFileSync(modulePath, moduleExports);
+    fs.writeFileSync(cjsPath, cjsExports);
+  }
+  const moduleEntry = path.join(rootDir, "dist", "index.js");
+  const moduleEntrySrc = fs.readFileSync(moduleEntry, "utf-8");
+  if (!moduleEntrySrc.includes("// tamagui-patch-v4")) {
+    fs.writeFileSync(moduleEntry, `${removePatch(moduleEntrySrc)}
+
+// tamagui-patch-v4
+import * as TExports from './tamagui-exports'
+export const TamaguiExports = TExports
+// tamagui-patch-end
+`);
+  }
+  const cjsEntry = path.join(rootDir, "dist", "cjs", "index.js");
+  const cjsEntrySrc = fs.readFileSync(cjsEntry, "utf-8");
+  if (!cjsEntrySrc.includes("// tamagui-patch-v4")) {
+    fs.writeFileSync(cjsEntry, `${removePatch(cjsEntrySrc)}
+
+// tamagui-patch-v4
+exports.TamaguiExports = _interopRequireDefault(require("./tamagui-exports"));
+// tamagui-patch-end
+`);
+  }
+}
+__name(patchReactNativeWeb, "patchReactNativeWeb");
+function removePatch(source) {
+  return source.replace(/\/\/ tamagui-patch([.\s\S]*)/g, "");
+}
+__name(removePatch, "removePatch");
+const forwardedPropsObj = `{
+  ...fwdProps.defaultProps,
+  ...fwdProps.accessibilityProps,
+  ...fwdProps.clickProps,
+  ...fwdProps.focusProps,
+  ...fwdProps.keyboardProps,
+  ...fwdProps.mouseProps,
+  ...fwdProps.touchProps,
+  ...fwdProps.styleProps,
+  href: true,
+  lang: true,
+  onScroll: true,
+  onWheel: true,
+  pointerEvents: true
+}
+`;
+const moduleExports = `
+export { atomic } from './exports/StyleSheet/compile'
+export { default as createCompileableStyle } from './exports/StyleSheet/createCompileableStyle'
+export { default as createReactDOMStyle } from './exports/StyleSheet/createReactDOMStyle'
+export { default as i18Style } from './exports/StyleSheet/i18nStyle'
+export { default as createDOMProps } from './modules/createDOMProps'
+export { default as AccessibilityUtil } from './modules/AccessibilityUtil'
+export { default as createElement } from './exports/createElement'
+export { default as css } from './exports/StyleSheet/css'
+export { default as TextAncestorContext } from './exports/Text/TextAncestorContext'
+export { default as pick } from './modules/pick'
+export { default as useElementLayout } from './modules/useElementLayout'
+export { default as useMergeRefs } from './modules/useMergeRefs'
+export { default as usePlatformMethods } from './modules/usePlatformMethods'
+export { default as useResponderEvents } from './modules/useResponderEvents'
+import * as fwdProps from './modules/forwardedProps'
+export const forwardedProps = ${forwardedPropsObj}
+`;
+const cjsExports = `
+exports.atomic = require('./exports/StyleSheet/compile').atomic
+exports.createCompileableStyle = require('./exports/StyleSheet/createCompileableStyle')
+exports.createReactDOMStyle = require('./exports/StyleSheet/createReactDOMStyle')
+exports.i18Style = require('./exports/StyleSheet/i18nStyle')
+exports.createDOMProps = require('./modules/createDOMProps')
+exports.AccessibilityUtil = require('./modules/AccessibilityUtil')
+exports.createElement = require('./exports/createElement')
+exports.css = require('./exports/StyleSheet/css')
+exports.TextAncestorContext = require('./exports/Text/TextAncestorContext')
+exports.pick = require('./modules/pick')
+exports.useElementLayout = require('./modules/useElementLayout')
+exports.useMergeRefs = require('./modules/useMergeRefs')
+exports.usePlatformMethods = require('./modules/usePlatformMethods')
+exports.useResponderEvents = require('./modules/useResponderEvents')
+const fwdProps = require('./modules/forwardedProps')
+exports.forwardedProps = ${forwardedPropsObj}
+`;
+export {
+  patchReactNativeWeb
+};

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@tamagui/static",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.12",
   "source": "src/index.ts",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "typings": "types.d.ts",
+  "typings": "types",
+  "main": "dist/cjs",
+  "module": "dist/esm",
+  "module:jsx": "dist/_jsx",
   "files": [
-    "types.d.ts",
-    "dist",
-    "src"
+    "types",
+    "src",
+    "dist"
   ],
   "scripts": {
     "build": "tamagui-build",
@@ -53,11 +54,11 @@
     "@babel/traverse": "^7.15.4",
     "@dish/babel-preset": "^0.0.6",
     "@expo/match-media": "^0.1.0",
-    "@tamagui/build": "^1.0.0-alpha.8",
-    "@tamagui/core": "^1.0.0-alpha.11",
-    "@tamagui/core-node": "^1.0.0-alpha.10",
+    "@tamagui/build": "^1.0.0-alpha.12",
+    "@tamagui/core": "^1.0.0-alpha.12",
+    "@tamagui/core-node": "^1.0.0-alpha.12",
     "@tamagui/fake-react-native": "^1.0.0-alpha.2",
-    "@tamagui/helpers": "^1.0.0-alpha.8",
+    "@tamagui/helpers": "^1.0.0-alpha.12",
     "babel-literal-to-ast": "^2.1.0",
     "esbuild": "^0.13.12",
     "esbuild-register": "^3.1.2",
@@ -65,10 +66,10 @@
     "fs-extra": "^9.0.0",
     "invariant": "^2.2.4",
     "lodash": "^4.17.20",
-    "tamagui": "^1.0.0-alpha.11"
+    "tamagui": "^1.0.0-alpha.12"
   },
   "peerDependencies": {
     "react-native-web": "*"
   },
-  "gitHead": "23209099ee7f37baf2597a9dcded9345ba294fe4"
+  "gitHead": "d50261a4e08d2212395af4f2d8f49555fc780c3e"
 }

package/types/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CSS_FILE_NAME = "__snack.css";
+export declare const MEDIA_SEP = "_";
+export declare const cacheDir: any;
+//# sourceMappingURL=constants.d.ts.map

package/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAI1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAG5B,eAAO,MAAM,QAAQ,KAAkD,CAAA"}

package/types/extractor/accessSafe.d.ts

@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function accessSafe(obj: t.Expression, member: string): t.LogicalExpression;
+//# sourceMappingURL=accessSafe.d.ts.map

package/types/extractor/accessSafe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessSafe.d.ts","sourceRoot":"","sources":["../../src/extractor/accessSafe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAIjC,wBAAgB,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,iBAAiB,CAajF"}

package/types/extractor/babelParse.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as babelParser from '@babel/parser';
+export declare const parserOptions: babelParser.ParserOptions;
+export declare function babelParse(code: string | Buffer): any;
+//# sourceMappingURL=babelParse.d.ts.map

package/types/extractor/babelParse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babelParse.d.ts","sourceRoot":"","sources":["../../src/extractor/babelParse.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,WAAW,MAAM,eAAe,CAAA;AAE5C,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,aAkBtC,CAAA;AAIF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAErD"}

package/types/extractor/buildClassName.d.ts

@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+import { ClassNameObject } from '../types';
+export declare function buildClassName(classNameObjects: ClassNameObject[]): t.Expression | t.StringLiteral | null;
+//# sourceMappingURL=buildClassName.d.ts.map

package/types/extractor/buildClassName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildClassName.d.ts","sourceRoot":"","sources":["../../src/extractor/buildClassName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAEjC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,eAAe,EAAE,GAClC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,aAAa,GAAG,IAAI,CAsDvC"}