@tamagui/web 1.116.0 → 1.116.2

package/dist/cjs/createFont.js

@@ -0,0 +1,53 @@
+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 createFont_exports = {};
+__export(createFont_exports, {
+  createFont: () => createFont
+});
+module.exports = __toCommonJS(createFont_exports);
+const fontWeights = [
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900"
+], processSection = (section, keys, defaultValue) => {
+  if (typeof section == "string") return section;
+  const sectionKeys = Object.keys(section);
+  let fillValue = section[sectionKeys[0]];
+  return Object.fromEntries(
+    [.../* @__PURE__ */ new Set([...keys, ...sectionKeys])].map((key) => {
+      const value = section[key] ?? defaultValue ?? fillValue;
+      return fillValue = value, defaultValue = value, [key, value];
+    })
+  );
+}, createFont = (font) => {
+  const sizeKeys = Object.keys(font.size), processedFont = Object.fromEntries(
+    Object.entries(font).map(([key, section]) => [
+      key,
+      processSection(
+        section,
+        key === "face" ? fontWeights : sizeKeys,
+        key === "face" ? { normal: font.family } : void 0
+      )
+    ])
+  );
+  return Object.freeze(processedFont);
+};
+//# sourceMappingURL=createFont.js.map

package/dist/cjs/createShorthands.js

@@ -0,0 +1,23 @@
+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 createShorthands_exports = {};
+__export(createShorthands_exports, {
+  createShorthands: () => createShorthands
+});
+module.exports = __toCommonJS(createShorthands_exports);
+function createShorthands(shorthands) {
+  return Object.freeze(shorthands);
+}
+//# sourceMappingURL=createShorthands.js.map

package/dist/cjs/createTamagui.js

@@ -0,0 +1,189 @@
+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 createTamagui_exports = {};
+__export(createTamagui_exports, {
+  createTamagui: () => createTamagui
+});
+module.exports = __toCommonJS(createTamagui_exports);
+var import_constants = require("@tamagui/constants"), import_config = require("./config"), import_createVariables = require("./createVariables"), import_getThemeCSSRules = require("./helpers/getThemeCSSRules"), import_insertStyleRule = require("./helpers/insertStyleRule"), import_proxyThemeToParents = require("./helpers/proxyThemeToParents"), import_registerCSSVariable = require("./helpers/registerCSSVariable"), import_themes = require("./helpers/themes"), import_useMedia = require("./hooks/useMedia"), import_insertFont = require("./insertFont"), import_Tamagui = require("./Tamagui");
+const createdConfigs = /* @__PURE__ */ new WeakMap();
+function createTamagui(configIn) {
+  if (createdConfigs.has(configIn))
+    return configIn;
+  const tokensParsed = {}, tokens = (0, import_createVariables.createVariables)(configIn.tokens || {});
+  if (configIn.tokens) {
+    const tokensMerged = {};
+    for (const cat in tokens) {
+      tokensParsed[cat] = {}, tokensMerged[cat] = {};
+      const tokenCat = tokens[cat];
+      for (const key in tokenCat) {
+        const val = tokenCat[key], prefixedKey = `$${key}`;
+        tokensParsed[cat][prefixedKey] = val, tokensMerged[cat][prefixedKey] = val, tokensMerged[cat][key] = val;
+      }
+    }
+    (0, import_config.setTokens)(tokensMerged);
+  }
+  let foundThemes;
+  if (configIn.themes) {
+    const noThemes = Object.keys(configIn.themes).length === 0;
+    noThemes && (foundThemes = (0, import_insertStyleRule.scanAllSheets)(noThemes, tokensParsed)), process.env.TAMAGUI_REACT_19 && process.env.TAMAGUI_SKIP_THEME_OPTIMIZATION || noThemes && (0, import_insertStyleRule.listenForSheetChanges)();
+  }
+  let fontSizeTokens = null, fontsParsed;
+  if (configIn.fonts) {
+    const fontTokens = Object.fromEntries(
+      Object.entries(configIn.fonts).map(([k, v]) => [k, (0, import_createVariables.createVariables)(v, "f", !0)])
+    );
+    fontsParsed = (() => {
+      const res = {};
+      for (const familyName in fontTokens) {
+        const font = fontTokens[familyName], fontParsed = (0, import_insertFont.parseFont)(font);
+        res[`$${familyName}`] = fontParsed, !fontSizeTokens && fontParsed.size && (fontSizeTokens = new Set(Object.keys(fontParsed.size)));
+      }
+      return res;
+    })();
+  }
+  const specificTokens = {}, themeConfig = (() => {
+    const cssRuleSets = [], declarations = [], fontDeclarations = {};
+    for (const key in tokens)
+      for (const skey in tokens[key]) {
+        const variable = tokens[key][skey];
+        if (specificTokens[`$${key}.${skey}`] = variable, process.env.NODE_ENV === "development" && typeof variable > "u")
+          throw new Error(
+            `No value for tokens.${key}.${skey}:
+${JSON.stringify(variable, null, 2)}`
+          );
+        import_constants.isWeb && ((0, import_registerCSSVariable.registerCSSVariable)(variable), declarations.push((0, import_registerCSSVariable.variableToCSS)(variable, key === "zIndex")));
+      }
+    if (import_constants.isWeb) {
+      let declarationsToRuleSet = function(decs, selector = "") {
+        return `:root${selector} {${sep}${[...decs].join(`;${sep}`)}${sep}}`;
+      };
+      for (const key in fontsParsed) {
+        const fontParsed = fontsParsed[key], [name, language] = key.includes("_") ? key.split("_") : [key], fontVars = (0, import_insertFont.registerFontVariables)(fontParsed);
+        fontDeclarations[key] = {
+          name: name.slice(1),
+          declarations: fontVars,
+          language
+        };
+      }
+      const sep = configIn.cssStyleSeparator || "";
+      if (cssRuleSets.push(declarationsToRuleSet(declarations)), fontDeclarations)
+        for (const key in fontDeclarations) {
+          const { name, declarations: declarations2, language = "default" } = fontDeclarations[key], fontSelector = `.font_${name}`, langSelector = `:root .t_lang-${name}-${language} ${fontSelector}`, selectors = language === "default" ? ` ${fontSelector}, ${langSelector}` : langSelector, specificRuleSet = declarationsToRuleSet(declarations2, selectors);
+          cssRuleSets.push(specificRuleSet);
+        }
+    }
+    const themesIn = configIn.themes, dedupedThemes = foundThemes ?? getThemesDeduped(themesIn);
+    return {
+      themes: (0, import_proxyThemeToParents.proxyThemesToParents)(dedupedThemes),
+      cssRuleSets,
+      getThemeRulesSets() {
+        let themeRuleSets = [];
+        if (import_constants.isWeb)
+          for (const { names, theme } of dedupedThemes) {
+            const nextRules = (0, import_getThemeCSSRules.getThemeCSSRules)({
+              config: configIn,
+              themeName: names[0],
+              names,
+              theme
+            });
+            themeRuleSets = [...themeRuleSets, ...nextRules];
+          }
+        return themeRuleSets;
+      }
+    };
+  })(), shorthands = configIn.shorthands || {};
+  let lastCSSInsertedRulesIndex = -1;
+  const getCSS = (opts = {}) => {
+    const { separator = `
+`, sinceLastCall, exclude } = opts;
+    if (sinceLastCall && lastCSSInsertedRulesIndex >= 0) {
+      const rules = (0, import_insertStyleRule.getAllRules)();
+      return lastCSSInsertedRulesIndex = rules.length, rules.slice(lastCSSInsertedRulesIndex).join(separator);
+    }
+    lastCSSInsertedRulesIndex = 0;
+    const runtimeStyles = (0, import_insertStyleRule.getAllRules)().join(separator);
+    return exclude === "design-system" ? runtimeStyles : `${`._ovs-contain {overscroll-behavior:contain;}
+.is_Text .is_Text {display:inline-flex;}
+._dsp_contents {display:contents;}
+${themeConfig.cssRuleSets.join(separator)}`}
+${exclude ? "" : themeConfig.getThemeRulesSets().join(separator)}
+${runtimeStyles}`;
+  }, getNewCSS = (opts) => getCSS({ ...opts, sinceLastCall: !0 }), defaultFontSetting = configIn.settings?.defaultFont ?? configIn.defaultFont, defaultFont = (() => {
+    let val = defaultFontSetting;
+    return val?.[0] === "$" && (val = val.slice(1)), val;
+  })(), defaultFontToken = defaultFont ? `$${defaultFont}` : "", unset = { ...configIn.unset };
+  !unset.fontFamily && defaultFont && (unset.fontFamily = defaultFontToken);
+  const config = {
+    fonts: {},
+    onlyAllowShorthands: !1,
+    fontLanguages: [],
+    animations: {},
+    media: {},
+    ...configIn,
+    unset,
+    settings: {
+      // move deprecated settings here so we can reference them all using `getSetting`
+      // TODO remove this on v2
+      disableSSR: configIn.disableSSR,
+      defaultFont: configIn.defaultFont,
+      disableRootThemeClass: configIn.disableRootThemeClass,
+      onlyAllowShorthands: configIn.onlyAllowShorthands,
+      mediaQueryDefaultActive: configIn.mediaQueryDefaultActive,
+      themeClassNameOnRoot: configIn.themeClassNameOnRoot,
+      cssStyleSeparator: configIn.cssStyleSeparator,
+      webContainerType: "inline-size",
+      ...configIn.settings
+    },
+    tokens,
+    // vite made this into a function if it wasn't set
+    shorthands,
+    inverseShorthands: shorthands ? Object.fromEntries(Object.entries(shorthands).map(([k, v]) => [v, k])) : {},
+    themes: themeConfig.themes,
+    fontsParsed: fontsParsed || {},
+    themeConfig,
+    tokensParsed,
+    parsed: !0,
+    getNewCSS,
+    getCSS,
+    defaultFont,
+    fontSizeTokens: fontSizeTokens || /* @__PURE__ */ new Set(),
+    specificTokens,
+    defaultFontToken
+    // const tokens = [...getToken(tokens.size[0])]
+    // .spacer-sm + ._dsp_contents._dsp-sm-hidden { margin-left: -var(--${}) }
+  };
+  return (0, import_config.setConfig)(config), (0, import_useMedia.configureMedia)(config), createdConfigs.set(config, !0), import_config.configListeners.size && (import_config.configListeners.forEach((cb) => cb(config)), import_config.configListeners.clear()), process.env.NODE_ENV === "development" && (process.env.DEBUG?.startsWith("tamagui") && console.info("Tamagui config:", config), globalThis.Tamagui || (globalThis.Tamagui = import_Tamagui.Tamagui)), config;
+}
+function getThemesDeduped(themes) {
+  const dedupedThemes = [], existing = /* @__PURE__ */ new Map();
+  for (const themeName in themes) {
+    const darkOrLightSpecificPrefix = themeName.startsWith("dark") ? "dark" : themeName.startsWith("light") ? "light" : "", rawTheme = themes[themeName], key = darkOrLightSpecificPrefix + JSON.stringify(rawTheme);
+    if (existing.has(key)) {
+      existing.get(key).names.push(themeName);
+      continue;
+    }
+    const theme = { ...rawTheme };
+    for (const key2 in theme)
+      (0, import_themes.ensureThemeVariable)(theme, key2);
+    const deduped = {
+      names: [themeName],
+      theme
+    };
+    dedupedThemes.push(deduped), existing.set(key, deduped);
+  }
+  return dedupedThemes;
+}
+//# sourceMappingURL=createTamagui.js.map

package/dist/cjs/createTheme.js

@@ -0,0 +1,21 @@
+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 createTheme_exports = {};
+__export(createTheme_exports, {
+  createTheme: () => createTheme
+});
+module.exports = __toCommonJS(createTheme_exports);
+const createTheme = (theme) => theme;
+//# sourceMappingURL=createTheme.js.map

package/dist/cjs/createTokens.js

@@ -0,0 +1,24 @@
+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 createTokens_exports = {};
+__export(createTokens_exports, {
+  createTokens: () => createTokens
+});
+module.exports = __toCommonJS(createTokens_exports);
+var import_createVariables = require("./createVariables");
+function createTokens(tokens) {
+  return (0, import_createVariables.createVariables)(tokens, process.env.TAMAGUI_TOKEN_PREFIX ?? "t");
+}
+//# sourceMappingURL=createTokens.js.map

package/dist/cjs/createVariable.js

@@ -0,0 +1,82 @@
+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 createVariable_exports = {};
+__export(createVariable_exports, {
+  createCSSVariable: () => createCSSVariable,
+  createVariable: () => createVariable,
+  didGetVariableValue: () => didGetVariableValue,
+  getVariable: () => getVariable,
+  getVariableName: () => getVariableName,
+  getVariableValue: () => getVariableValue,
+  getVariableVariable: () => getVariableVariable,
+  isVariable: () => isVariable,
+  setDidGetVariableValue: () => setDidGetVariableValue,
+  variableToString: () => variableToString
+});
+module.exports = __toCommonJS(createVariable_exports);
+var import_constants = require("@tamagui/constants"), import_helpers = require("@tamagui/helpers"), import_config = require("./config");
+function constructCSSVariableName(name) {
+  return `var(--${process.env.TAMAGUI_CSS_VARIABLE_PREFIX || ""}${name})`;
+}
+const createVariable = (props, skipHash = !1) => {
+  if (!skipHash && isVariable(props)) return props;
+  const { key, name, val } = props;
+  return {
+    isVar: !0,
+    key,
+    name: skipHash ? name : (0, import_helpers.simpleHash)(name, 40),
+    val,
+    variable: import_constants.isWeb ? skipHash ? constructCSSVariableName(name) : createCSSVariable(name) : ""
+  };
+};
+function variableToString(vrble, getValue = !1) {
+  return isVariable(vrble) ? !getValue && import_constants.isWeb && vrble.variable ? vrble.variable : `${vrble.val}` : `${vrble || ""}`;
+}
+function isVariable(v) {
+  return v && typeof v == "object" && "isVar" in v;
+}
+function getVariable(nameOrVariable, group = "size") {
+  if (nameOrVariable?.dynamic)
+    return nameOrVariable;
+  if (setDidGetVariableValue(!0), isVariable(nameOrVariable))
+    return variableToString(nameOrVariable);
+  const tokens = (0, import_config.getConfig)().tokensParsed;
+  return variableToString(tokens[group]?.[nameOrVariable] ?? nameOrVariable);
+}
+let accessed = !1;
+const setDidGetVariableValue = (val) => accessed = val, didGetVariableValue = () => accessed;
+function getVariableValue(v, group) {
+  if (isVariable(v))
+    return setDidGetVariableValue(!0), v.val;
+  if (group) {
+    const token = (0, import_config.getConfig)().tokensParsed[group]?.[v];
+    if (token)
+      return setDidGetVariableValue(!0), token.val;
+  }
+  return v;
+}
+function getVariableName(v) {
+  return isVariable(v) ? v.name : v;
+}
+function getVariableVariable(v) {
+  return isVariable(v) ? v.variable : v;
+}
+const createCSSVariable = (nameProp, includeVar = !0) => {
+  if (process.env.NODE_ENV === "development" && (!nameProp || typeof nameProp != "string"))
+    throw new Error(`createCSSVariable expected string, got: ${nameProp}`);
+  const name = (0, import_helpers.simpleHash)(nameProp, 60);
+  return includeVar ? constructCSSVariableName(name) : name;
+};
+//# sourceMappingURL=createVariable.js.map

package/dist/cjs/createVariables.js

@@ -0,0 +1,47 @@
+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 createVariables_exports = {};
+__export(createVariables_exports, {
+  createVariables: () => createVariables
+});
+module.exports = __toCommonJS(createVariables_exports);
+var import_helpers = require("@tamagui/helpers"), import_createVariable = require("./createVariable");
+const cache = /* @__PURE__ */ new WeakMap(), createVariables = (tokens, parentPath = "", isFont = !1) => {
+  if (cache.has(tokens)) return tokens;
+  const res = {};
+  let i = 0;
+  for (let keyIn in tokens) {
+    i++;
+    const val = tokens[keyIn], isPrefixed = keyIn[0] === "$", keyWithPrefix = isPrefixed ? keyIn : `$${keyIn}`, key = isPrefixed ? keyWithPrefix.slice(1) : keyIn;
+    if ((0, import_createVariable.isVariable)(val)) {
+      res[key] = val;
+      continue;
+    }
+    const niceKey = (0, import_helpers.simpleHash)(key, 1e3), name = parentPath && parentPath !== "t-color" ? `${parentPath}-${niceKey}` : `c-${niceKey}`;
+    if (val && typeof val == "object") {
+      res[key] = createVariables(
+        tokens[key],
+        name,
+        !1
+        /* note: don't pass isFont down, we want to avoid it past the first level */
+      );
+      continue;
+    }
+    const finalValue = (0, import_createVariable.isVariable)(val) ? val : (0, import_createVariable.createVariable)({ val, name, key: keyWithPrefix });
+    res[key] = finalValue;
+  }
+  return cache.set(res, !0), res;
+};
+//# sourceMappingURL=createVariables.js.map

package/dist/cjs/defaultComponentState.js

@@ -0,0 +1,33 @@
+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 defaultComponentState_exports = {};
+__export(defaultComponentState_exports, {
+  defaultComponentState: () => defaultComponentState,
+  defaultComponentStateMounted: () => defaultComponentStateMounted
+});
+module.exports = __toCommonJS(defaultComponentState_exports);
+const defaultComponentState = {
+  hover: !1,
+  press: !1,
+  pressIn: !1,
+  focus: !1,
+  focusVisible: !1,
+  unmounted: !0,
+  disabled: !1
+}, defaultComponentStateMounted = {
+  ...defaultComponentState,
+  unmounted: !1
+};
+//# sourceMappingURL=defaultComponentState.js.map

package/dist/cjs/helpers/ThemeManager.js

@@ -0,0 +1,166 @@
+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 ThemeManager_exports = {};
+__export(ThemeManager_exports, {
+  ThemeManager: () => ThemeManager,
+  getHasThemeUpdatingProps: () => getHasThemeUpdatingProps,
+  getManagers: () => getManagers
+});
+module.exports = __toCommonJS(ThemeManager_exports);
+var import_constants = require("@tamagui/constants"), import_config = require("../config"), import_constants2 = require("../constants/constants");
+const emptyState = { name: "" };
+function getHasThemeUpdatingProps(props) {
+  return !!(props.name || props.componentName || props.inverse || props.reset);
+}
+let uid = 0;
+class ThemeManager {
+  constructor(props = {}, parentManager) {
+    this.props = props;
+    if (uid = (uid + 1) % Number.MAX_VALUE, this.id = uid, parentManager === "root") {
+      this.updateStateFromProps(props, !1);
+      return;
+    }
+    if (!parentManager)
+      throw process.env.NODE_ENV !== "production" ? new Error(
+        "No parent manager given, this is likely due to duplicated Tamagui dependencies. Check your lockfile for mis-matched versions. It could also be from an error somewhere else in your stack causing Tamagui to recieve undefined context, you can try putting some ErrorBoundary components around other areas of your app, or a Suspense boundary."
+      ) : "\u274C 000";
+    if (this.parentManager = parentManager, !this.updateStateFromProps(props, !1))
+      return parentManager;
+  }
+  id = 0;
+  themeListeners = /* @__PURE__ */ new Set();
+  parentManager = null;
+  state = emptyState;
+  updateStateFromProps(props = this.props || {}, shouldNotify = !0) {
+    if (this.props = props, props.forceTheme)
+      return this.state.theme = props.forceTheme, this.state.name = props.name || "", this.updateState(this.state, !0), this.state;
+    const nextState = this.getStateIfChanged(props);
+    if (nextState)
+      return this.updateState(nextState, shouldNotify), nextState;
+  }
+  updateState(nextState, shouldNotify = !0) {
+    this.state = nextState, this._allKeys = null;
+  }
+  getStateIfChanged(props = this.props, state = this.state, parentManager = this.parentManager) {
+    const _ = this.getState(props, parentManager);
+    if (state && state !== emptyState && !_)
+      return parentManager?.state;
+    if (this.getStateShouldChange(_, state))
+      return _;
+  }
+  getStateShouldChange(nextState, state = this.state) {
+    return !(!nextState?.theme || nextState.theme === state?.theme);
+  }
+  getState(props = this.props, parentManager = this.parentManager) {
+    return getState(props, parentManager) || null;
+  }
+  _allKeys = null;
+  get allKeys() {
+    return this._allKeys ||= /* @__PURE__ */ new Set([
+      ...this.parentManager?.allKeys || [],
+      ...Object.keys(this.state.theme || {})
+    ]), this._allKeys;
+  }
+  notify(forced = !1) {
+    this.themeListeners.forEach((cb) => cb(this.state.name, this, forced)), process.env.NODE_ENV !== "production" && (this._numChangeEventsSent ??= 0, this._numChangeEventsSent++);
+  }
+  _selfListener;
+  selfUpdate() {
+    this._selfListener?.(this.state.name, this, "self");
+  }
+  onChangeTheme(cb, debugId) {
+    return process.env.NODE_ENV !== "production" && debugId && (this._listeningIds ??= /* @__PURE__ */ new Set(), this._listeningIds.add(debugId)), debugId === !0 && (this._selfListener = cb), this.themeListeners.add(cb), () => {
+      this.themeListeners.delete(cb);
+    };
+  }
+}
+function getState(props, manager) {
+  if (props.name && props.reset)
+    throw new Error(
+      process.env.NODE_ENV === "production" ? "\u274C004" : "Cannot reset and set a new name at the same time."
+    );
+  if (!getHasThemeUpdatingProps(props))
+    return null;
+  const themes = (0, import_config.getThemes)(), [allManagers, componentManagers] = getManagers(manager), isDirectParentAComponentTheme = !!manager?.state.isComponent, startIndex = props.reset && !isDirectParentAComponentTheme ? 1 : 0;
+  let baseManager = allManagers[startIndex], parentManager = allManagers[startIndex + 1];
+  if (!baseManager && props.reset)
+    return process.env.NODE_ENV !== "production" && console.warn("Cannot reset, no parent theme exists"), null;
+  const { componentName } = props;
+  let result = null, baseName = baseManager?.state.name || "";
+  baseManager?.state.isComponent && (baseName = baseName.replace(/_[A-Z][A-Za-z]+/, ""));
+  const nextName = props.reset ? baseName : props.name || "", allComponentThemes = componentManagers.map((x) => x?.state.name || "");
+  isDirectParentAComponentTheme && allComponentThemes.shift();
+  const base = baseName.split(import_constants2.THEME_NAME_SEPARATOR), max = base.length, min = props.componentName && !nextName ? max : 0;
+  for (let i = max; i >= min; i--) {
+    let prefix = base.slice(0, i).join(import_constants2.THEME_NAME_SEPARATOR);
+    props.inverse && (prefix = inverseThemeName(prefix));
+    let potentials = [];
+    if (prefix && prefix !== baseName && prefix.includes(nextName) && potentials.push(prefix), nextName && potentials.unshift(prefix ? `${prefix}_${nextName}` : nextName), i === 1) {
+      const lastSegment = potentials.findIndex((x) => !x.includes("_"));
+      lastSegment > 0 && potentials.splice(lastSegment, 0, nextName);
+    }
+    if (componentName && !props.reset) {
+      const baseLen = base.length;
+      let componentPotentials = [];
+      if (nextName && baseLen > 1) {
+        const beforeSeparator = base[0];
+        componentPotentials.push(`${beforeSeparator}_${nextName}_${componentName}`);
+      }
+      if (componentPotentials.push(`${prefix}_${componentName}`), nextName) {
+        if (i > baseLen) {
+          const prefixLessOne = base.slice(0, i - 1).join(import_constants2.THEME_NAME_SEPARATOR);
+          if (prefixLessOne) {
+            const lessSpecific = `${prefixLessOne}_${nextName}_${componentName}`;
+            componentPotentials.unshift(lessSpecific);
+          }
+        }
+        const moreSpecific = `${prefix}_${nextName}_${componentName}`;
+        componentPotentials.unshift(moreSpecific);
+      }
+      potentials = [...componentPotentials, ...potentials, ...allComponentThemes];
+    }
+    const found = potentials.find((t) => t in themes);
+    if (process.env.NODE_ENV !== "production" && typeof props.debug == "string" && import_constants.isClient && console.info(` \u{1F537} [${manager?.id}] getState`, {
+      props,
+      found,
+      potentials,
+      baseManager,
+      nextName,
+      baseName,
+      prefix
+    }), found) {
+      const names = found.split("_"), [firstName, ...restNames] = names, lastName = names[names.length - 1], isComponent = lastName[0] === lastName[0].toUpperCase(), scheme = firstName === "light" ? "light" : firstName === "dark" ? "dark" : void 0, pre = import_constants2.THEME_CLASSNAME_PREFIX, className = import_constants.isWeb ? `${pre}sub_theme ${pre}${!scheme || !restNames.length ? firstName : restNames.join("_")}` : "", parentName = (baseManager || parentManager)?.state?.name;
+      result = {
+        name: found,
+        parentName,
+        theme: themes[found],
+        className,
+        isComponent,
+        scheme
+      };
+      break;
+    }
+  }
+  return process.env.NODE_ENV !== "production" && props.debug === "verbose" && import_constants.isClient && (console.groupCollapsed("ThemeManager.getState()"), console.info({ props, baseName, base, min, max }), console.warn("result", { result }), console.trace(), console.groupEnd()), result;
+}
+const inverseThemeName = (themeName) => themeName.startsWith("light") ? themeName.replace(/^light/, "dark") : themeName.replace(/^dark/, "light");
+function getManagers(themeManager) {
+  const comp = [], all = [];
+  let cur = themeManager;
+  for (; cur; )
+    all.push(cur), cur.state.isComponent && comp.push(cur), cur = cur.parentManager;
+  return [all, comp];
+}
+//# sourceMappingURL=ThemeManager.js.map