@hanzogui/static 2.0.0

package/dist/extractor/createLogger.cjs

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var createLogger_exports = {};
+__export(createLogger_exports, {
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(createLogger_exports);
+var import_node_path = require("node:path"),
+  import_getPrefixLogs = require("./getPrefixLogs.cjs");
+function createLogger(sourcePath, options) {
+  const shouldLogTiming = options.logTimings ?? !0,
+    start = Date.now(),
+    mem = process.env.HANZO_GUI_SHOW_MEMORY_USAGE && shouldLogTiming ? process.memoryUsage() : null;
+  return res => {
+    if (!shouldLogTiming) return;
+    const memUsed = mem ? Math.round((process.memoryUsage().heapUsed - mem.heapUsed) / 1024 / 1204 * 10) / 10 : 0,
+      path = (0, import_node_path.basename)(sourcePath || "").replace(/\.[jt]sx?$/, "").slice(0, 22).trim().padEnd(24),
+      numOptimized = `${res.optimized + res.styled}`.padStart(3),
+      numFound = `${res.found + res.styled}`.padStart(3),
+      numFlattened = `${res.flattened}`.padStart(3),
+      memory = memUsed ? ` ${memUsed}MB` : "",
+      timingStr = `${Date.now() - start}ms`.padStart(6),
+      pre = (0, import_getPrefixLogs.getPrefixLogs)(options),
+      memStr = memory ? `(${memory})` : "";
+    console.info(`${pre} ${path}   \xB7  ${numFound} found   \xB7  ${numOptimized} opt   \xB7  ${numFlattened} flat  ${timingStr} ${memStr}`);
+  };
+}

package/dist/extractor/detectModuleFormat.cjs

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var detectModuleFormat_exports = {};
+__export(detectModuleFormat_exports, {
+  clearFormatCache: () => clearFormatCache,
+  detectModuleFormat: () => detectModuleFormat
+});
+module.exports = __toCommonJS(detectModuleFormat_exports);
+var import_node_fs = require("node:fs"),
+  import_node_path = require("node:path");
+const formatCache = /* @__PURE__ */new Map();
+function detectModuleFormat(filePath) {
+  const ext = (0, import_node_path.extname)(filePath);
+  if (ext === ".mjs") return "esm";
+  if (ext === ".cjs") return "cjs";
+  let dir = (0, import_node_path.dirname)(filePath);
+  for (;;) {
+    if (formatCache.has(dir)) return formatCache.get(dir);
+    try {
+      const format = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "package.json"), "utf-8")).type === "module" ? "esm" : "cjs";
+      return formatCache.set(dir, format), format;
+    } catch {}
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "cjs";
+}
+function clearFormatCache() {
+  formatCache.clear();
+}

package/dist/extractor/ensureImportingConcat.cjs

@@ -0,0 +1,48 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var ensureImportingConcat_exports = {};
+__export(ensureImportingConcat_exports, {
+  ensureImportingConcat: () => ensureImportingConcat
+});
+module.exports = __toCommonJS(ensureImportingConcat_exports);
+var t = __toESM(require("@babel/types"));
+const importConcatPkg = "@hanzogui/helpers";
+function ensureImportingConcat(path) {
+  const imported = path.get("body").find(x => x.isImportDeclaration() && x.node.source.value === importConcatPkg),
+    importSpecifier = t.importSpecifier(t.identifier("concatClassName"), t.identifier("concatClassName"));
+  if (!imported) {
+    path.node.body.push(t.importDeclaration([importSpecifier], t.stringLiteral(importConcatPkg)));
+    return;
+  }
+  const specifiers = imported.node.specifiers;
+  specifiers.some(x => t.isImportSpecifier(x) && t.isIdentifier(x.imported) && x.imported.name === "concatClassName") || specifiers.push(t.importSpecifier(t.identifier("concatClassName"), t.identifier("concatClassName")));
+}

package/dist/extractor/errors.cjs

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  BailOptimizationError: () => BailOptimizationError
+});
+module.exports = __toCommonJS(errors_exports);
+class BailOptimizationError extends Error {}

package/dist/extractor/esbuildAliasPlugin.cjs

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var esbuildAliasPlugin_exports = {};
+__export(esbuildAliasPlugin_exports, {
+  esbuildAliasPlugin: () => esbuildAliasPlugin
+});
+module.exports = __toCommonJS(esbuildAliasPlugin_exports);
+const esbuildAliasPlugin = config => {
+  const alias = config && Object.keys(config);
+  return {
+    name: "path-alias",
+    setup(build) {
+      if (!alias || !alias.length) return;
+      const main = (k, args) => ({
+        path: config[k].replace(/\/$/, "")
+      });
+      alias.forEach(k => {
+        build.onResolve({
+          filter: new RegExp(`^.*${k}$`)
+        }, args => main(k, args)), build.onResolve({
+          filter: new RegExp(`^.*\\/${k}\\/.*$`)
+        }, args => main(k, args));
+      });
+    }
+  };
+};

package/dist/extractor/esbuildTsconfigPaths.cjs

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name2 in all) __defProp(target, name2, {
+      get: all[name2],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var esbuildTsconfigPaths_exports = {};
+__export(esbuildTsconfigPaths_exports, {
+  TsconfigPathsPlugin: () => TsconfigPathsPlugin,
+  loadCompilerOptionsFromTsconfig: () => loadCompilerOptionsFromTsconfig
+});
+module.exports = __toCommonJS(esbuildTsconfigPaths_exports);
+var import_node_fs = __toESM(require("node:fs")),
+  import_node_path = __toESM(require("node:path")),
+  import_typescript = require("typescript");
+const name = "tsconfig-paths";
+function TsconfigPathsPlugin() {
+  const compilerOptions = loadCompilerOptionsFromTsconfig();
+  return {
+    name,
+    setup({
+      onResolve
+    }) {
+      onResolve({
+        filter: /.*/
+      }, args => {
+        if (args.path.startsWith("@hanzogui/")) return null;
+        const paths = compilerOptions.paths || {};
+        if (!Object.keys(paths).some(p => new RegExp(p.replace("*", "\\w*")).test(args.path))) return null;
+        const {
+          resolvedModule
+        } = (0, import_typescript.nodeModuleNameResolver)(args.path, args.importer, compilerOptions, import_typescript.sys);
+        if (!resolvedModule) return null;
+        const {
+          resolvedFileName
+        } = resolvedModule;
+        return !resolvedFileName || resolvedFileName.endsWith(".d.ts") ? null : {
+          path: resolvedFileName
+        };
+      });
+    }
+  };
+}
+function loadCompilerOptionsFromTsconfig(tsconfig) {
+  if (!tsconfig) {
+    const configPath = (0, import_typescript.findConfigFile)(process.cwd(), import_typescript.sys.fileExists, "tsconfig.json") || (0, import_typescript.findConfigFile)(process.cwd(), import_typescript.sys.fileExists, "jsconfig.json");
+    return configPath ? parseTsconfig(configPath) : {};
+  }
+  if (typeof tsconfig == "string") {
+    if (import_node_fs.default.existsSync(tsconfig)) return parseTsconfig(tsconfig);
+    throw new Error(`Specified tsconfig file not found: ${tsconfig}`);
+  }
+  const baseDir = process.cwd();
+  return (0, import_typescript.parseJsonConfigFileContent)(tsconfig, import_typescript.sys, baseDir).options;
+}
+function parseTsconfig(configFilePath) {
+  const configFile = (0, import_typescript.readConfigFile)(configFilePath, import_typescript.sys.readFile);
+  if (configFile.error) throw new Error(`Error reading tsconfig file '${configFilePath}': ${configFile.error.messageText}`);
+  const baseDir = import_node_path.default.dirname(configFilePath);
+  return (0, import_typescript.parseJsonConfigFileContent)(configFile.config, import_typescript.sys, baseDir).options;
+}

package/dist/extractor/evaluateAstNode.cjs

@@ -0,0 +1,83 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var evaluateAstNode_exports = {};
+__export(evaluateAstNode_exports, {
+  evaluateAstNode: () => evaluateAstNode
+});
+module.exports = __toCommonJS(evaluateAstNode_exports);
+var t = __toESM(require("@babel/types"));
+function evaluateAstNode(exprNode, evalFn, shouldPrintDebug) {
+  if (exprNode !== void 0) {
+    if (exprNode === null) return !0;
+    if (t.isJSXExpressionContainer(exprNode)) return evaluateAstNode(exprNode.expression);
+    if (t.isObjectExpression(exprNode)) {
+      const ret = {};
+      for (let idx = -1, len = exprNode.properties.length; ++idx < len;) {
+        const value = exprNode.properties[idx];
+        if (!t.isObjectProperty(value)) throw new Error("evaluateAstNode can only evaluate object properties");
+        let key;
+        if (value.computed) {
+          if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support computed keys unless an eval function is provided");
+          key = evaluateAstNode(value.key, evalFn);
+        } else if (t.isIdentifier(value.key)) key = value.key.name;else if (t.isStringLiteral(value.key) || t.isNumericLiteral(value.key)) key = value.key.value;else throw new Error("Unsupported key type: " + value.key.type);
+        if (typeof key != "string" && typeof key != "number") throw new Error("key must be either a string or a number");
+        ret[key] = evaluateAstNode(value.value, evalFn);
+      }
+      return ret;
+    }
+    if (t.isArrayExpression(exprNode)) return exprNode.elements.map(x => evaluateAstNode(x, evalFn));
+    if (t.isUnaryExpression(exprNode) && exprNode.operator === "-") {
+      const ret = evaluateAstNode(exprNode.argument, evalFn);
+      return ret == null ? null : -ret;
+    }
+    if (t.isTemplateLiteral(exprNode)) {
+      if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support template literals unless an eval function is provided");
+      let ret = "";
+      for (let idx = -1, len = exprNode.quasis.length; ++idx < len;) {
+        const quasi = exprNode.quasis[idx],
+          expr = exprNode.expressions[idx];
+        ret += quasi.value.raw, expr && (ret += evaluateAstNode(expr, evalFn));
+      }
+      return ret;
+    }
+    if (t.isNullLiteral(exprNode)) return null;
+    if (t.isNumericLiteral(exprNode) || t.isStringLiteral(exprNode) || t.isBooleanLiteral(exprNode)) return exprNode.value;
+    if (t.isBinaryExpression(exprNode)) {
+      if (exprNode.operator === "+") return evaluateAstNode(exprNode.left, evalFn) + evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "-") return evaluateAstNode(exprNode.left, evalFn) - evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "*") return evaluateAstNode(exprNode.left, evalFn) * evaluateAstNode(exprNode.right, evalFn);
+      if (exprNode.operator === "/") return evaluateAstNode(exprNode.left, evalFn) / evaluateAstNode(exprNode.right, evalFn);
+    }
+    if (typeof evalFn != "function") throw new Error("evaluateAstNode does not support non-literal values unless an eval function is provided");
+    return evalFn(exprNode);
+  }
+}

package/dist/extractor/extractHelpers.cjs

@@ -0,0 +1,119 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var extractHelpers_exports = {};
+__export(extractHelpers_exports, {
+  attrStr: () => attrStr,
+  findComponentName: () => findComponentName,
+  getValidComponent: () => getValidComponent,
+  getValidComponentsPaths: () => getValidComponentsPaths,
+  getValidImport: () => getValidImport,
+  isComponentPackage: () => isComponentPackage,
+  isInsideComponentPackage: () => isInsideComponentPackage,
+  isPresent: () => isPresent,
+  isSimpleSpread: () => isSimpleSpread,
+  isValidImport: () => isValidImport,
+  isValidModule: () => isValidModule,
+  isValidThemeHook: () => isValidThemeHook,
+  objToStr: () => objToStr,
+  ternaryStr: () => ternaryStr
+});
+module.exports = __toCommonJS(extractHelpers_exports);
+var import_node_path = require("node:path"),
+  import_generator = __toESM(require("@babel/generator")),
+  t = __toESM(require("@babel/types")),
+  import_find_root = __toESM(require("find-root")),
+  import_memoize = require("../helpers/memoize.cjs");
+function isPresent(input) {
+  return input != null;
+}
+function isSimpleSpread(node) {
+  return t.isIdentifier(node.argument) || t.isMemberExpression(node.argument);
+}
+const attrStr = attr => attr ? attr.type === "attr" ? getNameAttr(attr.value) : attr.type === "ternary" ? `...${ternaryStr(attr.value)}` : `${attr.type}(${objToStr(attr.value)})` : "",
+  objToStr = (obj, spacer = ", ") => obj ? `{${Object.entries(obj).map(([k, v]) => `${k}:${Array.isArray(v) ? "[...]" : v && typeof v == "object" ? `${objToStr(v, ",")}` : JSON.stringify(v)}`).join(spacer)}}` : `${obj}`,
+  getNameAttr = attr => t.isJSXSpreadAttribute(attr) ? `...${attr.argument.name}` : "name" in attr ? attr.name.name : `unknown-${attr.type}`,
+  ternaryStr = x => ["ternary(", t.isIdentifier(x.test) ? x.test.name : t.isMemberExpression(x.test) ? [x.test.object.name, x.test.property.name] :
+  // @ts-ignore
+  (0, import_generator.default)(x.test).code, isFilledObj(x.consequent) ? ` ? ${objToStr(x.consequent)}` : " ? \u{1F6AB}", isFilledObj(x.alternate) ? ` : ${objToStr(x.alternate)}` : " : \u{1F6AB}", ")"].flat().join(""),
+  isFilledObj = obj => obj && Object.keys(obj).length;
+function findComponentName(scope) {
+  let cur = scope.path;
+  for (; cur.parentPath && !t.isProgram(cur.parentPath.parent);) cur = cur.parentPath;
+  let node = cur.parent;
+  if (t.isExportNamedDeclaration(node) && (node = node.declaration), t.isVariableDeclaration(node)) {
+    const [dec] = node.declarations;
+    if (t.isVariableDeclarator(dec) && t.isIdentifier(dec.id)) return dec.id.name;
+  }
+  return t.isFunctionDeclaration(node) ? node.id?.name : "";
+}
+function isValidThemeHook(props, jsxPath, n, sourcePath) {
+  if (!t.isIdentifier(n.object) || !t.isIdentifier(n.property)) return !1;
+  const binding = jsxPath.scope.getAllBindings()[n.object.name];
+  if (!binding?.path || !binding.path.isVariableDeclarator()) return !1;
+  const init = binding.path.node.init;
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useTheme") return !1;
+  const importNode = binding.scope.getBinding("useTheme")?.path.parent;
+  return !(!t.isImportDeclaration(importNode) || sourcePath && !isValidImport(props, sourcePath));
+}
+const isInsideComponentPackage = (props, moduleName) => getValidComponentsPaths(props).some(path => moduleName.startsWith(path)),
+  isComponentPackage = (props, srcName) => getValidComponentsPaths(props).some(path => srcName.startsWith(path));
+function getValidComponent(props, moduleName, componentName) {
+  if (componentName[0].toUpperCase() !== componentName[0]) return !1;
+  for (const loaded of props.allLoadedComponents) {
+    if (!loaded) continue;
+    const isInModule = moduleName === "*" || moduleName.startsWith(loaded.moduleName),
+      foundComponent = loaded.nameToInfo[componentName];
+    if (isInModule && foundComponent) return foundComponent;
+  }
+  return null;
+}
+const isValidModule = (props, moduleName) => {
+    if (typeof moduleName != "string") throw new Error("No module name");
+    const isLocal = moduleName.startsWith(".");
+    return {
+      isLocal,
+      isValid: isLocal ? isInsideComponentPackage(props, moduleName) : isComponentPackage(props, moduleName)
+    };
+  },
+  getValidImport = (props, moduleName, componentName) => {
+    const {
+      isValid,
+      isLocal
+    } = isValidModule(props, moduleName);
+    return !isValid || !componentName ? null : getValidComponent(props, isLocal ? "*" : moduleName, componentName) || null;
+  },
+  isValidImport = (props, moduleName, componentName) => componentName ? !!getValidImport(props, moduleName, componentName) : isValidModule(props, moduleName).isValid,
+  getValidComponentPackages = (0, import_memoize.memoize)(props => [... /* @__PURE__ */new Set(["@hanzogui/core", "@hanzo/gui", ...(props.components || [])])]),
+  getValidComponentsPaths = (0, import_memoize.memoize)(props => getValidComponentPackages(props).flatMap(pkg => {
+    const root = (0, import_find_root.default)(pkg);
+    return [(0, import_node_path.basename)(root), pkg].filter(Boolean);
+  }));

package/dist/extractor/extractMediaStyle.cjs

@@ -0,0 +1,128 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var extractMediaStyle_exports = {};
+__export(extractMediaStyle_exports, {
+  extractMediaStyle: () => extractMediaStyle,
+  isValidMediaCall: () => isValidMediaCall
+});
+module.exports = __toCommonJS(extractMediaStyle_exports);
+var t = __toESM(require("@babel/types")),
+  core = __toESM(require("@hanzogui/core")),
+  import_requireGuiCore = require("../helpers/requireGuiCore.cjs"),
+  import_extractHelpers = require("./extractHelpers.cjs");
+function extractMediaStyle(props, ternary, jsxPath, guiConfig, sourcePath, importance = 0, shouldPrintDebug = !1) {
+  const {
+      getCSSStylesAtomic
+    } = (0, import_requireGuiCore.requireGuiCore)("web"),
+    mt = getMediaQueryTernary(props, ternary, jsxPath, sourcePath);
+  if (!mt) return null;
+  const {
+    key
+  } = mt;
+  if (!guiConfig.media[key]) return console.error(`Media query "${key}" not found: ${Object.keys(guiConfig.media)}`), null;
+  const getStyleObj = (styleObj, negate = !1) => styleObj ? {
+      styleObj,
+      negate
+    } : null,
+    styleOpts = [getStyleObj(ternary.consequent, !1), getStyleObj(ternary.alternate, !0)].filter(import_extractHelpers.isPresent);
+  if (shouldPrintDebug && !styleOpts.length) return console.info("  media query, no styles?"), null;
+  const mediaKeyPrecendence = Object.keys(guiConfig.media).reduce((acc, cur, i) => (acc[cur] = new Array(importance + 1).fill(":root").join(""), acc), {});
+  let mediaStyles = [];
+  for (const {
+    styleObj,
+    negate
+  } of styleOpts) {
+    const singleMediaStyles = getCSSStylesAtomic(styleObj).map(style => {
+      const mediaStyle = core.createMediaStyle(style, key, guiConfig.media, !0, negate),
+        className = `.${mediaStyle[core.StyleObjectIdentifier]}`;
+      return {
+        ...mediaStyle,
+        className
+      };
+    });
+    shouldPrintDebug === "verbose" && console.info("  media styles:", importance, styleObj, singleMediaStyles.map(x => x[core.StyleObjectIdentifier]).join(", ")), mediaStyles = [...mediaStyles, ...singleMediaStyles];
+  }
+  return ternary.remove(), {
+    mediaStyles,
+    ternaryWithoutMedia: mt.ternaryWithoutMedia
+  };
+}
+function getMediaQueryTernary(props, ternary, jsxPath, sourcePath) {
+  if (t.isLogicalExpression(ternary.test) && ternary.test.operator === "&&") {
+    const mediaLeft = getMediaInfoFromExpression(props, ternary.test.left, jsxPath, sourcePath, ternary.inlineMediaQuery);
+    if (mediaLeft) return {
+      ...mediaLeft,
+      ternaryWithoutMedia: {
+        ...ternary,
+        test: ternary.test.right
+      }
+    };
+  }
+  const result = getMediaInfoFromExpression(props, ternary.test, jsxPath, sourcePath, ternary.inlineMediaQuery);
+  return result ? {
+    ...result,
+    ternaryWithoutMedia: null
+  } : null;
+}
+function getMediaInfoFromExpression(props, test, jsxPath, sourcePath, inlineMediaQuery) {
+  if (inlineMediaQuery) return {
+    key: inlineMediaQuery,
+    bindingName: inlineMediaQuery
+  };
+  if (t.isMemberExpression(test) && t.isIdentifier(test.object) && t.isIdentifier(test.property)) {
+    const name = test.object.name,
+      key = test.property.name,
+      binding = jsxPath.scope.getAllBindings()[name];
+    if (!binding) return !1;
+    const bindingNode = binding.path?.node;
+    return !t.isVariableDeclarator(bindingNode) || !bindingNode.init || !isValidMediaCall(props, jsxPath, bindingNode.init, sourcePath) ? !1 : {
+      key,
+      bindingName: name
+    };
+  }
+  if (t.isIdentifier(test)) {
+    const key = test.name,
+      node = jsxPath.scope.getBinding(test.name)?.path?.node;
+    return !t.isVariableDeclarator(node) || !node.init || !isValidMediaCall(props, jsxPath, node.init, sourcePath) ? !1 : {
+      key,
+      bindingName: key
+    };
+  }
+  return null;
+}
+function isValidMediaCall(props, jsxPath, init, sourcePath) {
+  if (!init || !t.isCallExpression(init) || !t.isIdentifier(init.callee) || init.callee.name !== "useMedia") return !1;
+  const mediaBinding = jsxPath.scope.getAllBindings().useMedia;
+  if (!mediaBinding) return !1;
+  const useMediaImport = mediaBinding.path.parent;
+  return !(!t.isImportDeclaration(useMediaImport) || !(0, import_extractHelpers.isValidImport)(props, sourcePath));
+}