@kbach/ui 0.1.0-beta.0

package/dist/chunk-UE54W6ZG.mjs

@@ -0,0 +1,208 @@
+'use client';
+import {
+  EMPTY_BREAKPOINTS,
+  InteractiveWrapper,
+  composeNativeStyle,
+  expandModeAwareColorClasses,
+  flatten,
+  getActiveBreakpoints,
+  getConfig,
+  getDefaultFontFamily,
+  getEffectiveIsWeb,
+  getGlobalScreens,
+  getImpliedRNClasses,
+  getInteractiveModifiers,
+  getModeModifiers,
+  getResponsiveModifiers,
+  getWebTag,
+  hasResponsiveBuckets,
+  isNative,
+  isRuntimeCSSDisabled,
+  normalizeClassString,
+  onConfigChange,
+  resolve,
+  stripInternalMarkers,
+  stripWebOnlyProps,
+  transformToWebProps,
+  useConditionalGlobalDarkMode,
+  useConditionalWidth
+} from "./chunk-BPCFICND.mjs";
+
+// src/jsx-runtime.tsx
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+
+// src/DarkWrapper.tsx
+import React, { useMemo } from "react";
+var DarkWrapper = React.forwardRef(
+  function DarkWrapper2({ Component, resolvedStyle, style: styleProp, children, ...rest }, ref) {
+    const isWebPlatform = getEffectiveIsWeb();
+    const isDark = useConditionalGlobalDarkMode(!isWebPlatform);
+    const needsWidth = hasResponsiveBuckets(resolvedStyle);
+    const width = useConditionalWidth(needsWidth && !isWebPlatform);
+    const breakpoints = needsWidth ? getActiveBreakpoints(width) : EMPTY_BREAKPOINTS;
+    const screens = getGlobalScreens();
+    const isNonStringComponent = typeof Component !== "string";
+    const computedStyle = useMemo(() => {
+      if (isWebPlatform) return {};
+      const s = flatten(resolvedStyle, isDark, {}, breakpoints);
+      stripInternalMarkers(s);
+      if (isNonStringComponent) stripWebOnlyProps(s);
+      return s;
+    }, [resolvedStyle, isDark, width, screens, isNonStringComponent]);
+    const skipComputedInline = isWebPlatform;
+    const finalStyle = skipComputedInline ? styleProp ?? void 0 : composeNativeStyle(computedStyle, styleProp);
+    const props = { ref, ...rest, style: finalStyle };
+    return Array.isArray(children) ? React.createElement(Component, props, ...children) : React.createElement(Component, props, children);
+  }
+);
+DarkWrapper.displayName = "Kbach.DarkWrapper";
+
+// src/jsx-runtime.tsx
+var _cachedDefaultFont = void 0;
+var _defaultFontVersion = 0;
+var _lastFontVersion = -1;
+function _invalidateDefaultFontCache() {
+  _defaultFontVersion++;
+}
+{
+  const _KEY = "__kbach_font_cache_unsub__";
+  const g = globalThis;
+  if (g[_KEY]) g[_KEY]();
+  g[_KEY] = onConfigChange(_invalidateDefaultFontCache);
+}
+function getCachedDefaultFont() {
+  if (_lastFontVersion !== _defaultFontVersion) {
+    _cachedDefaultFont = getDefaultFontFamily();
+    _lastFontVersion = _defaultFontVersion;
+  }
+  return _cachedDefaultFont;
+}
+var _bucketModsCache = /* @__PURE__ */ new WeakMap();
+function bucketMods(resolved) {
+  const cached = _bucketModsCache.get(resolved);
+  if (cached) return cached;
+  const interactiveMods = getInteractiveModifiers();
+  const modeMods = getModeModifiers();
+  const responsiveMods = getResponsiveModifiers();
+  let interactive = false;
+  let modeOrResponsive = false;
+  for (const key of Object.keys(resolved)) {
+    if (key === "base") continue;
+    for (const mod of key.split(":")) {
+      if (!interactive && interactiveMods.has(mod)) interactive = true;
+      if (!modeOrResponsive && (modeMods.has(mod) || responsiveMods.has(mod))) modeOrResponsive = true;
+    }
+    if (interactive && modeOrResponsive) break;
+  }
+  const result = { interactive, modeOrResponsive };
+  _bucketModsCache.set(resolved, result);
+  return result;
+}
+var CONSUMED_PROPS = /* @__PURE__ */ new Set(["className", "kb", "__kbachStyles", "__kbachClasses"]);
+function omitConsumed(props) {
+  const out = {};
+  for (const key of Object.keys(props)) {
+    if (!CONSUMED_PROPS.has(key)) out[key] = props[key];
+  }
+  return out;
+}
+function makeElement(isStaticChildren, type, props, key) {
+  return (isStaticChildren ? _jsxs : _jsx)(type, props, key);
+}
+function processElement(type, rawProps, key, isStaticChildren) {
+  if (type === null || typeof type === "symbol") return makeElement(isStaticChildren, type, rawProps ?? {}, key);
+  const webTag = getEffectiveIsWeb() ? getWebTag(type, rawProps ?? void 0) : null;
+  const effectiveType = webTag ?? type;
+  const originalName = webTag ? type?.displayName ?? type?.name : void 0;
+  if (!rawProps) return _jsx(effectiveType, null, key);
+  const workingProps = webTag && originalName ? transformToWebProps(originalName, webTag, rawProps) : rawProps;
+  const { className, kb: kbProp, __kbachStyles, __kbachClasses } = workingProps;
+  const classStrRaw = className ?? kbProp ?? __kbachClasses;
+  if (classStrRaw !== void 0 && typeof classStrRaw !== "string") {
+    return makeElement(isStaticChildren, effectiveType, workingProps, key);
+  }
+  const classStr = classStrRaw;
+  const config = getConfig();
+  let expandedClassStr = classStr ? expandModeAwareColorClasses(classStr, config.theme.colors) : classStr;
+  if (!isNative && isRuntimeCSSDisabled() && expandedClassStr && !__kbachStyles) {
+    const { style: userStyle2, ...passProps2 } = omitConsumed(workingProps);
+    return makeElement(isStaticChildren, effectiveType, {
+      ...passProps2,
+      className: normalizeClassString(expandedClassStr),
+      ...userStyle2 !== void 0 ? { style: userStyle2 } : {}
+    }, key);
+  }
+  if (classStr && !__kbachStyles && /^(__[A-Za-z0-9_]+\s*)+$/.test(classStr.trim())) {
+    const { style: userStyle2, ...passProps2 } = omitConsumed(workingProps);
+    return makeElement(isStaticChildren, effectiveType, {
+      ...passProps2,
+      className: classStr,
+      ...userStyle2 !== void 0 ? { style: userStyle2 } : {}
+    }, key);
+  }
+  if (!classStr && !__kbachStyles) {
+    if (getEffectiveIsWeb()) return makeElement(isStaticChildren, effectiveType, omitConsumed(workingProps), key);
+    const defaultFont = getCachedDefaultFont();
+    if (!defaultFont || getWebTag(type) !== "span") {
+      return makeElement(isStaticChildren, effectiveType, workingProps, key);
+    }
+    const { style: userStyle2, ...passProps2 } = omitConsumed(workingProps);
+    const finalStyle2 = userStyle2 ? Array.isArray(userStyle2) ? { fontFamily: defaultFont, ...Object.assign({}, ...userStyle2) } : { fontFamily: defaultFont, ...userStyle2 } : { fontFamily: defaultFont };
+    return makeElement(isStaticChildren, effectiveType, { ...passProps2, style: finalStyle2 }, key);
+  }
+  let resolved = isNative && __kbachStyles != null ? __kbachStyles : expandedClassStr ? resolve(expandedClassStr, config.theme, config.darkMode) : {};
+  const impliedClasses = getImpliedRNClasses(webTag, resolved.base);
+  if (impliedClasses) {
+    expandedClassStr = expandedClassStr ? `${expandedClassStr} ${impliedClasses}` : impliedClasses;
+    resolved = resolve(expandedClassStr, config.theme, config.darkMode);
+  }
+  const { style: userStyle, ...passProps } = omitConsumed(workingProps);
+  const { interactive, modeOrResponsive } = bucketMods(resolved);
+  if (interactive) {
+    return _jsx(InteractiveWrapper, {
+      Component: effectiveType,
+      resolvedStyle: resolved,
+      ...!isNative && expandedClassStr ? { className: normalizeClassString(expandedClassStr) } : {},
+      style: userStyle,
+      ...passProps
+    }, key);
+  }
+  if (modeOrResponsive) {
+    return _jsx(DarkWrapper, {
+      Component: effectiveType,
+      resolvedStyle: resolved,
+      ...!isNative && expandedClassStr ? { className: normalizeClassString(expandedClassStr) } : {},
+      style: userStyle,
+      ...passProps
+    }, key);
+  }
+  const skipComputedInline = getEffectiveIsWeb();
+  let finalStyle;
+  if (!skipComputedInline) {
+    const computedStyle = flatten(resolved, false);
+    stripInternalMarkers(computedStyle);
+    if (typeof effectiveType !== "string") stripWebOnlyProps(computedStyle);
+    finalStyle = composeNativeStyle(computedStyle, userStyle);
+  } else {
+    finalStyle = userStyle ?? void 0;
+  }
+  return makeElement(isStaticChildren, effectiveType, {
+    ...passProps,
+    ...finalStyle !== void 0 ? { style: finalStyle } : {},
+    ...!isNative && expandedClassStr ? { className: normalizeClassString(expandedClassStr) } : {}
+  }, key);
+}
+function jsx(type, props, key) {
+  return processElement(type, props, key, false);
+}
+function jsxs(type, props, key) {
+  return processElement(type, props, key, true);
+}
+
+export {
+  Fragment,
+  _invalidateDefaultFontCache,
+  jsx,
+  jsxs
+};