@kuma-ui/compiler/dist/extractor/index.js

🐻 Kuma UI is a utility-first, zero-runtime CSS-in-JS library that offers an outstanding developer experience and optimized performance.

"use strict";
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: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__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: true }), mod);

// src/extractor/index.ts
var extractor_exports = {};
__export(extractor_exports, {
  extractProps: () => extractProps
});
module.exports = __toCommonJS(extractor_exports);

// src/extractor/extract.ts
var import_ts_morph = require("ts-morph");
var import_system = require("@kuma-ui/system");
var import_componentList = require("@kuma-ui/core/components/componentList");
var import_sheet = require("@kuma-ui/sheet");
var extractProps = (componentName, jsx, propsMap) => {
  const styledProps = {};
  const pseudoProps = {};
  const componentProps = {};
  const variant = import_sheet.theme.getVariants(componentName);
  const baseStyleProps = {
    ...variant?.baseStyle
  };
  const systemDefaultProps = (0, import_componentList.componentDefaultProps)(componentName);
  const userDefaultProps = variant?.defaultProps;
  let isDefault = false;
  for (const [propName, propValue] of Object.entries({
    ...systemDefaultProps,
    ...userDefaultProps,
    ...propsMap
  })) {
    if ((0, import_system.isStyledProp)(propName)) {
      styledProps[propName] = propValue;
    } else if ((0, import_system.isPseudoProps)(propName)) {
      pseudoProps[propName] = propValue;
    } else if ((0, import_componentList.isComponentProps)(componentName)(propName)) {
      componentProps[propName] = propValue;
    } else if (propName === "variant") {
      Object.assign(baseStyleProps, variant?.variants?.[propValue]);
      jsx.getAttribute("variant")?.remove();
    } else if (propName === "IS_KUMA_DEFAULT") {
      isDefault = true;
    }
  }
  if (!(!!Object.keys(styledProps).length || !!Object.keys(pseudoProps).length || !!Object.keys(componentProps))) {
    return;
  }
  const specificProps = (0, import_componentList.componentHandler)(componentName)(componentProps);
  if (componentName === "Box" && isDefault) {
    for (const prop in baseStyleProps) {
      if (Object.hasOwn(baseStyleProps, prop)) {
        delete baseStyleProps[prop];
      }
    }
  }
  const combinedProps = {
    ...baseStyleProps,
    ...specificProps,
    ...styledProps,
    ...pseudoProps
  };
  const { className: generatedClassName, css } = new import_system.StyleGenerator(
    combinedProps
  ).getStyle();
  if (!generatedClassName)
    return { css };
  const classNameAttr = jsx.getAttribute("className");
  let newClassName = generatedClassName;
  let newClassNameInitializer = "";
  if (classNameAttr && import_ts_morph.Node.isJsxAttribute(classNameAttr)) {
    const initializer = classNameAttr.getInitializer();
    if (import_ts_morph.Node.isStringLiteral(initializer)) {
      const existingClassName = initializer.getLiteralText();
      if (existingClassName)
        newClassName += " " + existingClassName;
      newClassNameInitializer = `"${newClassName}"`;
    } else if (import_ts_morph.Node.isJsxExpression(initializer)) {
      const expression = initializer.getExpression();
      if (expression) {
        newClassNameInitializer = `\`${newClassName} \${${expression.getText()}}\``;
      }
    }
    classNameAttr.remove();
  } else {
    newClassNameInitializer = `"${newClassName}"`;
  }
  for (const styledPropKey of Object.keys(styledProps)) {
    jsx.getAttribute(styledPropKey)?.remove();
  }
  for (const pseudoPropKey of Object.keys(pseudoProps)) {
    jsx.getAttribute(pseudoPropKey)?.remove();
  }
  for (const componentPropsKey of Object.keys(componentProps)) {
    jsx.getAttribute(componentPropsKey)?.remove();
  }
  jsx.addAttribute({
    name: "className",
    initializer: `{${newClassNameInitializer}}`
  });
  return { css };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  extractProps
});