@bamboocss/parser 1.11.1 → 1.11.2

package/dist/index.js

@@ -1,1049 +0,0 @@
-"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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ParserResult: () => ParserResult,
-  Project: () => Project
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/project.ts
-var import_ts_morph2 = require("ts-morph");
-
-// src/classify.ts
-var import_extractor = require("@bamboocss/extractor");
-var import_shared = require("@bamboocss/shared");
-function addTo(map, key, value) {
-  const set = map.get(key) ?? /* @__PURE__ */ new Set();
-  set.add(value);
-  map.set(key, set);
-}
-function classifyProject(ctx, resultMap) {
-  const byId = /* @__PURE__ */ new Map();
-  const byComponentIndex = /* @__PURE__ */ new Map();
-  const byFilepath = /* @__PURE__ */ new Map();
-  const byComponentInFilepath = /* @__PURE__ */ new Map();
-  const globalMaps = createReportMaps();
-  const byFilePathMaps = /* @__PURE__ */ new Map();
-  const conditions = new Map(Object.entries(ctx.conditions.values));
-  const { groupByProp } = getPropertyGroupMap(ctx);
-  let id = 0;
-  let componentIndex = 0;
-  const isKnownUtility = (reportItem, componentReportItem) => {
-    const { propName, value, tokenType } = reportItem;
-    const utility = ctx.utility.config[propName];
-    if (utility) {
-      if (ctx.tokens.getByName(`${tokenType}.${value}`)) return true;
-      if (ctx.tokens.getReferences(String(value)).length > 0) return true;
-      if (ctx.utility.resolveColorMix(String(value)).color) return true;
-      return false;
-    }
-    if (componentReportItem.reportItemType === "pattern") {
-      const pattern = ctx.patterns.getConfig(componentReportItem.componentName.toLowerCase());
-      const patternProp = pattern?.properties?.[propName];
-      if (!patternProp) return false;
-      if (patternProp.type === "boolean" || patternProp.type === "number") {
-        return true;
-      }
-      if (patternProp.type === "property" && patternProp.value) {
-        return Boolean(ctx.utility.config[patternProp.value]);
-      }
-      if (patternProp.type === "enum" && patternProp.value) {
-        return Boolean(patternProp.value.includes(String(value)));
-      }
-      if (patternProp.type === "token") {
-        return Boolean(ctx.tokens.getByName(`${patternProp.value}.${value}`));
-      }
-      return false;
-    }
-    return false;
-  };
-  const processPattern = (opts) => {
-    const { boxNode, data, item, filepath, localMaps } = opts;
-    const name = item.componentName;
-    const pattern = ctx.patterns.details.find((p) => p.match.test(name) || p.baseName === name);
-    if (!pattern) return;
-    const cssObj = pattern.config.transform?.(data || {}, import_shared.patternFns) ?? {};
-    const newItem = {
-      name: "css",
-      type: "css",
-      box: import_extractor.box.objectToMap((0, import_shared.compact)(cssObj), boxNode.getNode(), boxNode.getStack()),
-      data: [cssObj]
-    };
-    Object.assign(newItem, { debug: true });
-    return processResultItem({ item: newItem, kind: "function", localMaps, filepath });
-  };
-  const processResultItem = (opts) => {
-    const { item, kind, filepath, localMaps } = opts;
-    if (!item.box || import_extractor.box.isUnresolvable(item.box)) {
-      return;
-    }
-    if (!item.data) {
-      return;
-    }
-    const componentReportItem = {
-      componentIndex: String(componentIndex++),
-      componentName: item.name,
-      reportItemType: item.type,
-      kind,
-      filepath,
-      value: item.data,
-      range: item.box.getRange(),
-      contains: [],
-      debug: Reflect.has(item, "debug")
-    };
-    if (item.type === "pattern" || item.type === "jsx-pattern") {
-      return processPattern({ boxNode: item.box, data: item.data[0], item: componentReportItem, filepath, localMaps });
-    }
-    if (import_extractor.box.isArray(item.box)) {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      return componentReportItem;
-    }
-    if (import_extractor.box.isMap(item.box)) {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      processMap({ map: item.box, current: [], componentReportItem, filepath, localMaps });
-      return componentReportItem;
-    }
-    if (item.type === "recipe") {
-      addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
-      return componentReportItem;
-    }
-  };
-  const processResultItemFn = (opts) => {
-    const { item, filepath, localMaps, type } = opts;
-    const componentReportItem = processResultItem({ item, kind: type, filepath, localMaps });
-    if (!componentReportItem) return;
-    addTo(globalMaps.byComponentOfKind, type, componentReportItem.componentIndex);
-    addTo(localMaps.byComponentOfKind, type, componentReportItem.componentIndex);
-    byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
-  };
-  const processMap = (opts) => {
-    const { map, current, componentReportItem, filepath, localMaps, skipRange } = opts;
-    const { reportItemType: type, kind, componentName: name } = componentReportItem;
-    map.value.forEach((attrNode, attrName) => {
-      if (import_extractor.box.isLiteral(attrNode) || import_extractor.box.isEmptyInitializer(attrNode)) {
-        const value = import_extractor.box.isLiteral(attrNode) ? attrNode.value : true;
-        const propReportItem = {
-          index: String(id++),
-          componentIndex: String(componentReportItem.componentIndex),
-          componentName: name,
-          tokenType: void 0,
-          propName: attrName,
-          reportItemKind: "utility",
-          reportItemType: type,
-          kind,
-          filepath,
-          path: current.concat(attrName),
-          value,
-          isKnownValue: false,
-          range: skipRange ? null : map.getRange()
-        };
-        componentReportItem.contains.push(propReportItem.index);
-        if (conditions.has(attrName)) {
-          addTo(globalMaps.byConditionName, attrName, propReportItem.index);
-          addTo(localMaps.byConditionName, attrName, propReportItem.index);
-          propReportItem.propName = current[0] ?? attrName;
-          propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
-          propReportItem.conditionName = attrName;
-        } else {
-          if (current.length && conditions.has(current[0])) {
-            propReportItem.conditionName = current[0];
-            addTo(globalMaps.byConditionName, current[0], propReportItem.index);
-            addTo(localMaps.byConditionName, current[0], propReportItem.index);
-          }
-          const propName = ctx.utility.resolveShorthand(attrName);
-          const tokenType = ctx.utility.getTokenType(propName);
-          if (tokenType) {
-            propReportItem.reportItemKind = "token";
-            propReportItem.tokenType = tokenType;
-          }
-          propReportItem.propName = propName;
-          propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
-          addTo(globalMaps.byPropertyName, propName, propReportItem.index);
-          addTo(localMaps.byPropertyName, propName, propReportItem.index);
-          if (tokenType) {
-            addTo(globalMaps.byTokenType, tokenType, propReportItem.index);
-            addTo(localMaps.byTokenType, tokenType, propReportItem.index);
-          }
-          if (propName.toLowerCase().includes("color") || groupByProp.get(propName) === "Color" || tokenType === "colors") {
-            addTo(globalMaps.colorsUsed, value, propReportItem.index);
-            addTo(localMaps.colorsUsed, value, propReportItem.index);
-          }
-          if (ctx.utility.shorthands.has(attrName)) {
-            addTo(globalMaps.byShorthand, attrName, propReportItem.index);
-            addTo(localMaps.byShorthand, attrName, propReportItem.index);
-          }
-        }
-        if (current.length) {
-          addTo(globalMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
-          addTo(localMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
-        }
-        addTo(globalMaps.byTokenName, String(value), propReportItem.index);
-        addTo(localMaps.byTokenName, String(value), propReportItem.index);
-        addTo(globalMaps.byType, type, propReportItem.index);
-        addTo(localMaps.byType, type, propReportItem.index);
-        addTo(globalMaps.byComponentName, name, propReportItem.index);
-        addTo(localMaps.byComponentName, name, propReportItem.index);
-        addTo(globalMaps.fromKind, kind, propReportItem.index);
-        addTo(localMaps.fromKind, kind, propReportItem.index);
-        addTo(byFilepath, filepath, propReportItem.index);
-        byId.set(propReportItem.index, propReportItem);
-        return;
-      }
-      if (import_extractor.box.isMap(attrNode) && attrNode.value.size) {
-        return processMap({
-          map: attrNode,
-          current: current.concat(attrName),
-          componentReportItem,
-          filepath,
-          localMaps
-        });
-      }
-    });
-  };
-  resultMap.forEach((parserResult, filepath) => {
-    if (parserResult.isEmpty()) return;
-    const localMaps = createReportMaps();
-    const componentFn = (item) => {
-      processResultItemFn({ item, filepath, localMaps, type: "component" });
-    };
-    const functionFn = (item) => {
-      processResultItemFn({ item, filepath, localMaps, type: "function" });
-    };
-    parserResult.jsx.forEach(componentFn);
-    parserResult.css.forEach(functionFn);
-    parserResult.cva.forEach(functionFn);
-    parserResult.pattern.forEach((itemList) => {
-      itemList.forEach(functionFn);
-    });
-    parserResult.recipe.forEach((itemList) => {
-      itemList.forEach(functionFn);
-    });
-    byFilePathMaps.set(filepath, localMaps);
-  });
-  const pickCount = 10;
-  const filesWithMostComponent = Object.fromEntries(
-    Array.from(byComponentInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount)
-  );
-  Object.entries(ctx.recipes.config).forEach(([key, recipe]) => {
-    const localMaps = createReportMaps();
-    const functionFn = (styleObject) => {
-      if (!styleObject) return;
-      const componentReportItem = {
-        componentIndex: "0",
-        componentName: `recipes.${key}.base`,
-        reportItemType: "css",
-        kind: "function",
-        filepath: `theme/recipes/${key}`,
-        value: styleObject,
-        range: null,
-        contains: []
-      };
-      processMap({
-        // @ts-expect-error
-        map: import_extractor.box.objectToMap(styleObject, null, []),
-        current: [],
-        filepath: `@config/theme/recipes/${key}`,
-        skipRange: true,
-        localMaps,
-        componentReportItem
-      });
-    };
-    const isSlotRecipe = (_v) => ctx.recipes.isSlotRecipe(key);
-    if (isSlotRecipe(recipe)) {
-      Object.values(recipe.base ?? {}).forEach(functionFn);
-      Object.values(recipe.variants ?? {}).forEach((variants) => {
-        Object.values(variants).forEach((v) => {
-          Object.values(v).forEach(functionFn);
-        });
-      });
-      recipe.compoundVariants?.forEach((v) => {
-        Object.values(v.css).forEach(functionFn);
-      });
-    } else {
-      functionFn(recipe.base);
-      Object.values(recipe.variants ?? {}).forEach((variants) => {
-        Object.values(variants).forEach(functionFn);
-      });
-      recipe.compoundVariants?.forEach((v) => functionFn(v.css));
-    }
-  });
-  Object.values(ctx.config.globalCss ?? {}).forEach((styleObject) => {
-    if (!styleObject) return;
-    processMap({
-      // @ts-expect-error
-      map: import_extractor.box.objectToMap(styleObject, null, []),
-      current: [],
-      filepath: "@config/globalCss",
-      skipRange: true,
-      localMaps: createReportMaps(),
-      componentReportItem: {
-        componentIndex: "0",
-        componentName: "global",
-        reportItemType: "css",
-        kind: "function",
-        filepath: "global",
-        value: styleObject,
-        range: null,
-        contains: []
-      }
-    });
-  });
-  return {
-    propById: byId,
-    componentById: byComponentIndex,
-    details: {
-      counts: {
-        filesWithTokens: byFilepath.size,
-        propNameUsed: globalMaps.byPropertyName.size,
-        tokenUsed: globalMaps.byTokenName.size,
-        shorthandUsed: globalMaps.byShorthand.size,
-        propertyPathUsed: globalMaps.byPropertyPath.size,
-        typeUsed: globalMaps.byType.size,
-        componentNameUsed: globalMaps.byComponentName.size,
-        kindUsed: globalMaps.fromKind.size,
-        componentOfKindUsed: globalMaps.byComponentOfKind.size,
-        colorsUsed: globalMaps.colorsUsed.size
-      },
-      stats: {
-        filesWithMostComponent,
-        mostUseds: getXMostUseds(globalMaps, 10)
-      }
-    },
-    derived: {
-      byFilepath,
-      byComponentInFilepath,
-      globalMaps,
-      byFilePathMaps
-    }
-  };
-}
-var getXMostUseds = (globalMaps, pickCount) => {
-  return {
-    propNames: getMostUsedInMap(globalMaps.byPropertyName, pickCount),
-    tokens: getMostUsedInMap(globalMaps.byTokenName, pickCount),
-    shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
-    conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
-    propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
-    categories: getMostUsedInMap(globalMaps.byTokenType, pickCount),
-    types: getMostUsedInMap(globalMaps.byType, pickCount),
-    componentNames: getMostUsedInMap(globalMaps.byComponentName, pickCount),
-    fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
-    componentOfKinds: getMostUsedInMap(globalMaps.byComponentOfKind, pickCount),
-    colors: getMostUsedInMap(globalMaps.colorsUsed, pickCount)
-  };
-};
-var getMostUsedInMap = (map, pickCount) => {
-  return Array.from(map.entries()).map(([key, list]) => [key, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount).map(([key, count]) => ({ key, count }));
-};
-var defaultGroupNames = [
-  "System",
-  "Container",
-  "Display",
-  "Visibility",
-  "Position",
-  "Transform",
-  "Flex Layout",
-  "Grid Layout",
-  "Layout",
-  "Border",
-  "Border Radius",
-  "Width",
-  "Height",
-  "Margin",
-  "Padding",
-  "Color",
-  "Typography",
-  "Background",
-  "Shadow",
-  "Table",
-  "List",
-  "Scroll",
-  "Interactivity",
-  "Transition",
-  "Effect",
-  "Other",
-  "Focus Ring"
-];
-function getPropertyGroupMap(ctx) {
-  const groups = new Map(defaultGroupNames.map((name) => [name, /* @__PURE__ */ new Set()]));
-  const groupByProp = /* @__PURE__ */ new Map();
-  const systemGroup = groups.get("System");
-  systemGroup.add("base");
-  systemGroup.add("colorPalette");
-  const otherStyleProps = groups.get("Other");
-  Object.entries(ctx.utility.config).map(([key, value]) => {
-    const group = value?.group;
-    if (!group) {
-      otherStyleProps.add(key);
-      return;
-    }
-    if (!groups.has(group)) {
-      groups.set(group, /* @__PURE__ */ new Set());
-    }
-    const set = groups.get(group);
-    if (value.shorthand) {
-      if (Array.isArray(value.shorthand)) {
-        value.shorthand.forEach((shorthand) => {
-          set.add(shorthand);
-          groupByProp.set(shorthand, group);
-        });
-      } else {
-        set.add(value.shorthand);
-        groupByProp.set(value.shorthand, group);
-      }
-    }
-    set.add(key);
-    groupByProp.set(key, group);
-  });
-  return { groups, groupByProp };
-}
-function createReportMaps() {
-  return {
-    byComponentOfKind: /* @__PURE__ */ new Map(),
-    byPropertyName: /* @__PURE__ */ new Map(),
-    byTokenType: /* @__PURE__ */ new Map(),
-    byConditionName: /* @__PURE__ */ new Map(),
-    byShorthand: /* @__PURE__ */ new Map(),
-    byTokenName: /* @__PURE__ */ new Map(),
-    byPropertyPath: /* @__PURE__ */ new Map(),
-    fromKind: /* @__PURE__ */ new Map(),
-    byType: /* @__PURE__ */ new Map(),
-    byComponentName: /* @__PURE__ */ new Map(),
-    colorsUsed: /* @__PURE__ */ new Map()
-  };
-}
-
-// src/parser.ts
-var import_extractor2 = require("@bamboocss/extractor");
-var import_logger = require("@bamboocss/logger");
-var import_shared3 = require("@bamboocss/shared");
-var import_ts_morph = require("ts-morph");
-var import_ts_pattern = require("ts-pattern");
-
-// src/get-import-declarations.ts
-var import_ts_path = require("@bamboocss/config/ts-path");
-
-// src/get-module-specifier-value.ts
-var getModuleSpecifierValue = (node) => {
-  try {
-    return node.getModuleSpecifierValue();
-  } catch {
-    return;
-  }
-};
-
-// src/get-import-declarations.ts
-function getImportDeclarations(context, sourceFile) {
-  const { imports, tsOptions } = context;
-  const importDeclarations = [];
-  sourceFile.getImportDeclarations().forEach((node) => {
-    const mod = getModuleSpecifierValue(node);
-    if (!mod) return;
-    node.getNamedImports().forEach((specifier) => {
-      const name = specifier.getNameNode().getText();
-      const alias = specifier.getAliasNode()?.getText() || name;
-      const result = { name, alias, mod, kind: "named" };
-      const found = imports.match(result, (mod2) => {
-        if (!tsOptions?.pathMappings) return;
-        return (0, import_ts_path.resolveTsPathPattern)(tsOptions.pathMappings, mod2);
-      });
-      if (!found) return;
-      importDeclarations.push(result);
-    });
-    const namespace = node.getNamespaceImport();
-    if (namespace) {
-      const name = namespace.getText();
-      const result = { name, alias: name, mod, kind: "namespace" };
-      const found = imports.match(result, (mod2) => {
-        if (!tsOptions?.pathMappings) return;
-        return (0, import_ts_path.resolveTsPathPattern)(tsOptions.pathMappings, mod2);
-      });
-      if (!found) return;
-      importDeclarations.push(result);
-    }
-  });
-  return importDeclarations;
-}
-
-// src/parser-result.ts
-var import_shared2 = require("@bamboocss/shared");
-function cartesian(arrays) {
-  if (arrays.length === 0) return [[]];
-  const [first, ...rest] = arrays;
-  const restProduct = cartesian(rest);
-  return first.flatMap((item) => restProduct.map((combo) => [item, ...combo]));
-}
-var ParserResult = class {
-  constructor(context, encoder) {
-    this.context = context;
-    this.encoder = encoder ?? context.encoder;
-  }
-  /** Ordered list of all ResultItem */
-  all = [];
-  jsx = /* @__PURE__ */ new Set();
-  css = /* @__PURE__ */ new Set();
-  cva = /* @__PURE__ */ new Set();
-  sva = /* @__PURE__ */ new Set();
-  token = /* @__PURE__ */ new Set();
-  recipe = /* @__PURE__ */ new Map();
-  pattern = /* @__PURE__ */ new Map();
-  filePath;
-  encoder;
-  append(result) {
-    this.all.push(result);
-    return result;
-  }
-  set(name, result) {
-    switch (name) {
-      case "css":
-        this.setCss(result);
-        break;
-      case "cva":
-        this.setCva(result);
-        break;
-      case "sva":
-        this.setSva(result);
-        break;
-      case "token":
-        this.setToken(result);
-        break;
-      default:
-        throw new import_shared2.BambooError(
-          "UNKNOWN_RESULT_TYPE",
-          `Unknown parser result type: "${name}". Expected one of: css, cva, sva, token`
-        );
-    }
-  }
-  setCss(result) {
-    this.css.add(this.append(Object.assign({ type: "css" }, result)));
-    const encoder = this.encoder;
-    const grouped = this.context.config.cssMode === "grouped";
-    if (!grouped || result.data.length <= 1) {
-      result.data.forEach((obj) => grouped ? encoder.processGrouped(obj) : encoder.processAtomic(obj));
-      return;
-    }
-    const keyCounts = /* @__PURE__ */ new Map();
-    for (const obj of result.data) {
-      for (const key of Object.keys(obj)) {
-        keyCounts.set(key, (keyCounts.get(key) || 0) + 1);
-      }
-    }
-    const hasOverlap = Array.from(keyCounts.values()).some((c) => c > 1);
-    if (!hasOverlap) {
-      encoder.processGrouped(Object.assign({}, ...result.data));
-      return;
-    }
-    const overlappingKeys = /* @__PURE__ */ new Set();
-    keyCounts.forEach((count, key) => {
-      if (count > 1) overlappingKeys.add(key);
-    });
-    const base = {};
-    const branchEntries = [];
-    for (const obj of result.data) {
-      if (Object.keys(obj).some((k) => overlappingKeys.has(k))) {
-        branchEntries.push(obj);
-      } else {
-        Object.assign(base, obj);
-      }
-    }
-    const branchGroups = /* @__PURE__ */ new Map();
-    for (const entry of branchEntries) {
-      const keySet = Object.keys(entry).sort().join("\0");
-      const group = branchGroups.get(keySet) || [];
-      group.push(entry);
-      branchGroups.set(keySet, group);
-    }
-    const groupArrays = Array.from(branchGroups.values());
-    const totalCombinations = groupArrays.reduce((acc, g) => acc * g.length, 1);
-    if (totalCombinations > 32) {
-      result.data.forEach((obj) => encoder.processGrouped(obj));
-      return;
-    }
-    for (const combo of cartesian(groupArrays)) {
-      encoder.processGrouped(Object.assign({}, base, ...combo));
-    }
-  }
-  setCva(result) {
-    this.cva.add(this.append(Object.assign({ type: "cva" }, result)));
-    const encoder = this.encoder;
-    result.data.forEach((data) => encoder.processAtomicRecipe(data));
-  }
-  setSva(result) {
-    this.sva.add(this.append(Object.assign({ type: "sva" }, result)));
-    const encoder = this.encoder;
-    result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
-  }
-  setToken(result) {
-    this.token.add(this.append(Object.assign({ type: "token" }, result)));
-  }
-  setJsx(result) {
-    this.jsx.add(this.append(Object.assign({ type: "jsx" }, result)));
-    const encoder = this.encoder;
-    const grouped = this.context.config.cssMode === "grouped";
-    result.data.forEach((obj) => encoder.processStyleProps(obj, grouped));
-  }
-  setPattern(name, result) {
-    const set = (0, import_shared2.getOrCreateSet)(this.pattern, name);
-    set.add(this.append(Object.assign({ type: "pattern", name }, result)));
-    const encoder = this.encoder;
-    result.data.forEach(
-      (obj) => encoder.processPattern(name, obj, result.type ?? "pattern", result.name)
-    );
-  }
-  setRecipe(recipeName, result) {
-    const set = (0, import_shared2.getOrCreateSet)(this.recipe, recipeName);
-    set.add(this.append(Object.assign({ type: "recipe" }, result)));
-    const encoder = this.encoder;
-    const recipes = this.context.recipes;
-    const recipeConfig = recipes.getConfig(recipeName);
-    if (!recipeConfig) return;
-    const recipe = result;
-    if (result.type) {
-      recipe.data.forEach((data) => {
-        const [recipeProps, styleProps] = recipes.splitProps(recipeName, data);
-        encoder.processStyleProps(styleProps);
-        encoder.processRecipe(recipeName, recipeProps);
-      });
-    } else {
-      recipe.data.forEach((data) => {
-        encoder.processRecipe(recipeName, data);
-      });
-    }
-  }
-  isEmpty() {
-    return this.all.length === 0;
-  }
-  setFilePath(filePath) {
-    this.filePath = filePath;
-    return this;
-  }
-  merge(result) {
-    result.css.forEach((item) => this.css.add(this.append(item)));
-    result.cva.forEach((item) => this.cva.add(this.append(item)));
-    result.sva.forEach((item) => this.sva.add(this.append(item)));
-    result.token.forEach((item) => this.token.add(this.append(item)));
-    result.jsx.forEach((item) => this.jsx.add(this.append(item)));
-    result.recipe.forEach((items, name) => {
-      const set = (0, import_shared2.getOrCreateSet)(this.recipe, name);
-      items.forEach((item) => set.add(this.append(item)));
-    });
-    result.pattern.forEach((items, name) => {
-      const set = (0, import_shared2.getOrCreateSet)(this.pattern, name);
-      items.forEach((item) => set.add(this.append(item)));
-    });
-    return this;
-  }
-  toArray() {
-    return this.all;
-  }
-  toJSON() {
-    return {
-      css: Array.from(this.css),
-      cva: Array.from(this.cva),
-      sva: Array.from(this.sva),
-      token: Array.from(this.token),
-      jsx: Array.from(this.jsx),
-      recipe: Object.fromEntries(Array.from(this.recipe.entries()).map(([key, value]) => [key, Array.from(value)])),
-      pattern: Object.fromEntries(Array.from(this.pattern.entries()).map(([key, value]) => [key, Array.from(value)]))
-    };
-  }
-};
-
-// src/parser.ts
-var combineResult = (unboxed) => {
-  return [...unboxed.conditions, unboxed.raw, ...unboxed.spreadConditions];
-};
-var defaultEnv = {
-  preset: "ECMA"
-};
-var evaluateOptions = {
-  environment: defaultEnv
-};
-function createParser(context) {
-  const { jsx, imports, recipes, config } = context;
-  const syntax = config.syntax;
-  return function parse(sourceFile, encoder, options) {
-    if (!sourceFile) return;
-    const importDeclarations = getImportDeclarations(context, sourceFile);
-    const file = imports.file(importDeclarations);
-    const filePath = sourceFile.getFilePath();
-    import_logger.logger.debug(
-      "ast:import",
-      !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`
-    );
-    const parserResult = new ParserResult(context, encoder);
-    if (file.isEmpty() && !jsx.isEnabled) {
-      return parserResult;
-    }
-    const extractResultByName = (0, import_extractor2.extract)({
-      ast: sourceFile,
-      tokens: context.tokens ? {
-        view: context.tokens.view,
-        isTokenFn: (fnName) => file.isTokenAlias(fnName)
-      } : void 0,
-      components: jsx.isEnabled ? {
-        matchTag: (prop) => {
-          if (options?.matchTag) {
-            const isBambooComponent = file.isBambooComponent(prop.tagName);
-            const matchTagMode = options.matchTagMode ?? "extend";
-            const isCustomMatch = options.matchTag(prop.tagName, isBambooComponent);
-            if (matchTagMode === "override") {
-              return isCustomMatch;
-            }
-            return isBambooComponent || isCustomMatch;
-          }
-          return !!file.matchTag(prop.tagName);
-        },
-        matchProp: (prop) => {
-          const isBambooProp = file.matchTagProp(prop.tagName, prop.propName);
-          if (options?.matchTagProp) {
-            return isBambooProp && options.matchTagProp(prop.tagName, prop.propName);
-          }
-          return isBambooProp;
-        }
-      } : void 0,
-      functions: {
-        matchFn: (prop) => file.matchFn(prop.fnName),
-        matchProp: () => true,
-        matchArg: (prop) => {
-          if (file.isJsxFactory(prop.fnName) && prop.index === 1 && import_ts_morph.Node.isIdentifier(prop.argNode)) return false;
-          return true;
-        }
-      },
-      taggedTemplates: syntax === "template-literal" ? {
-        matchTaggedTemplate: (tag) => file.matchFn(tag.fnName)
-      } : void 0,
-      getEvaluateOptions: (node) => {
-        if (!import_ts_morph.Node.isCallExpression(node)) return evaluateOptions;
-        const propAccessExpr = node.getExpression();
-        if (!import_ts_morph.Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
-        let name = propAccessExpr.getText();
-        if (!file.isRawFn(name)) {
-          return evaluateOptions;
-        }
-        name = name.replace(".raw", "");
-        return {
-          environment: Object.assign({}, defaultEnv, {
-            extra: {
-              [name]: { raw: (v) => v }
-            }
-          })
-        };
-      },
-      flags: { skipTraverseFiles: true }
-    });
-    extractResultByName.forEach((result, alias) => {
-      const name = file.getName(file.normalizeFnName(alias));
-      import_logger.logger.debug(`ast:${name}`, name !== alias ? { kind: result.kind, alias } : { kind: result.kind });
-      if (result.kind === "function") {
-        (0, import_ts_pattern.match)(name).when(imports.matchers.css.match, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              if (query.box.value.length > 1) {
-                parserResult.set(name2, {
-                  name: name2,
-                  box: query.box,
-                  data: query.box.value.reduce(
-                    (acc, value) => [...acc, ...combineResult((0, import_extractor2.unbox)(value))],
-                    []
-                  )
-                });
-              } else {
-                parserResult.set(name2, {
-                  name: name2,
-                  box: query.box.value[0] ?? import_extractor2.box.fallback(query.box),
-                  data: combineResult((0, import_extractor2.unbox)(query.box.value[0]))
-                });
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = (0, import_shared3.astish)(query.box.value);
-              parserResult.set(name2, {
-                name: name2,
-                box: query.box ?? import_extractor2.box.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).when(imports.matchers.tokens.match, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setToken({
-                name: name2,
-                box: query.box.value[0] ?? import_extractor2.box.fallback(query.box),
-                data: combineResult((0, import_extractor2.unbox)(query.box.value[0]))
-              });
-            }
-          });
-        }).when(file.isValidPattern, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setPattern(name2, {
-                name: name2,
-                box: query.box.value[0] ?? import_extractor2.box.fallback(query.box),
-                data: combineResult((0, import_extractor2.unbox)(query.box.value[0]))
-              });
-            }
-          });
-        }).when(file.isValidRecipe, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              parserResult.setRecipe(name2, {
-                name: name2,
-                box: query.box.value[0] ?? import_extractor2.box.fallback(query.box),
-                data: combineResult((0, import_extractor2.unbox)(query.box.value[0]))
-              });
-            }
-          });
-        }).when(jsx.isJsxFactory, () => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression" && query.box.value[1]) {
-              const map = query.box.value[1];
-              const boxNode = import_extractor2.box.isMap(map) ? map : import_extractor2.box.fallback(query.box);
-              const combined = combineResult((0, import_extractor2.unbox)(boxNode));
-              const transformed = options?.transform?.({ type: "jsx-factory", data: combined });
-              const result2 = { name, box: boxNode, data: transformed ?? combined };
-              if (import_extractor2.box.isRecipe(map)) {
-                parserResult.setCva(result2);
-              } else {
-                parserResult.set("css", result2);
-              }
-              const recipeOptions = query.box.value[2];
-              if (import_extractor2.box.isUnresolvable(map) && recipeOptions && import_extractor2.box.isMap(recipeOptions) && recipeOptions.value.has("defaultProps")) {
-                const maybeIdentifier = map.getNode();
-                if (import_ts_morph.Node.isIdentifier(maybeIdentifier)) {
-                  const name2 = maybeIdentifier.getText();
-                  const recipeName = file.getName(name2);
-                  parserResult.setRecipe(recipeName, {
-                    type: "jsx-recipe",
-                    name: recipeName,
-                    box: recipeOptions,
-                    data: combineResult((0, import_extractor2.unbox)(recipeOptions.value.get("defaultProps")))
-                  });
-                }
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = (0, import_shared3.astish)(query.box.value);
-              parserResult.set("css", {
-                name,
-                box: query.box ?? import_extractor2.box.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).when(file.isJsxFactory, (name2) => {
-          result.queryList.forEach((query) => {
-            if (query.kind === "call-expression") {
-              const map = query.box.value[0];
-              const boxNode = import_extractor2.box.isMap(map) ? map : import_extractor2.box.fallback(query.box);
-              const combined = combineResult((0, import_extractor2.unbox)(boxNode));
-              const transformed = options?.transform?.({ type: "jsx-factory", data: combined });
-              const result2 = { name: name2, box: boxNode, data: transformed ?? combined };
-              if (import_extractor2.box.isRecipe(map)) {
-                parserResult.setCva(result2);
-              } else {
-                parserResult.set("css", result2);
-              }
-            } else if (query.kind === "tagged-template") {
-              const obj = (0, import_shared3.astish)(query.box.value);
-              parserResult.set("css", {
-                name: name2,
-                box: query.box ?? import_extractor2.box.fallback(query.box),
-                data: [obj]
-              });
-            }
-          });
-        }).otherwise(() => {
-        });
-      } else if (jsx.isEnabled && result.kind === "component") {
-        result.queryList.forEach((query) => {
-          const data = combineResult((0, import_extractor2.unbox)(query.box));
-          switch (true) {
-            case (file.isJsxFactory(name) || file.isJsxFactory(alias)): {
-              parserResult.setJsx({ type: "jsx-factory", name, box: query.box, data });
-              break;
-            }
-            case (jsx.isJsxTagPattern(name) || jsx.isJsxTagPattern(alias)): {
-              parserResult.setPattern(name, { type: "jsx-pattern", name, box: query.box, data });
-              break;
-            }
-            // name: Trigger
-            case jsx.isJsxTagRecipe(name): {
-              const matchingRecipes = recipes.filter(name);
-              matchingRecipes.map((recipe) => {
-                parserResult.setRecipe(recipe.baseName, { type: "jsx-recipe", name, box: query.box, data });
-              });
-              break;
-            }
-            // alias: Tabs.Trigger
-            case jsx.isJsxTagRecipe(alias): {
-              const matchingRecipes = recipes.filter(alias);
-              matchingRecipes.map((recipe) => {
-                parserResult.setRecipe(recipe.baseName, { type: "jsx-recipe", name: alias, box: query.box, data });
-              });
-              break;
-            }
-            default: {
-              parserResult.setJsx({ type: "jsx", name, box: query.box, data });
-            }
-          }
-        });
-      }
-    });
-    return parserResult;
-  };
-}
-
-// src/project.ts
-var normalizeCompilerOptions = (raw) => {
-  if (!raw) return {};
-  const { options } = import_ts_morph2.ts.convertCompilerOptionsFromJson(raw, process.cwd());
-  return options;
-};
-var createTsProject = (options) => new import_ts_morph2.Project({
-  skipAddingFilesFromTsConfig: true,
-  skipFileDependencyResolution: true,
-  skipLoadingLibFiles: true,
-  ...options,
-  compilerOptions: {
-    allowJs: true,
-    strictNullChecks: false,
-    skipLibCheck: true,
-    ...normalizeCompilerOptions(options.compilerOptions)
-  }
-});
-var Project = class {
-  constructor(options) {
-    this.options = options;
-    const { parserOptions } = options;
-    this.project = createTsProject(options);
-    this.parser = createParser(parserOptions);
-    this.createSourceFiles();
-  }
-  project;
-  parser;
-  get parserOptions() {
-    return this.options.parserOptions;
-  }
-  get files() {
-    return this.options.getFiles();
-  }
-  getSourceFile = (filePath) => {
-    return this.project.getSourceFile(filePath);
-  };
-  createSourceFile = (filePath) => {
-    const { readFile } = this.options;
-    return this.project.createSourceFile(filePath, readFile(filePath), {
-      overwrite: true,
-      scriptKind: import_ts_morph2.ScriptKind.TSX
-    });
-  };
-  createSourceFiles = () => {
-    const files = this.getFiles();
-    for (const file of files) {
-      this.createSourceFile(file);
-    }
-  };
-  addSourceFile = (filePath, content) => {
-    return this.project.createSourceFile(filePath, content, {
-      overwrite: true,
-      scriptKind: import_ts_morph2.ScriptKind.TSX
-    });
-  };
-  removeSourceFile = (filePath) => {
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (sourceFile) {
-      return this.project.removeSourceFile(sourceFile);
-    }
-    return false;
-  };
-  reloadSourceFile = (filePath) => {
-    return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
-  };
-  reloadSourceFiles = () => {
-    const files = this.getFiles();
-    for (const file of files) {
-      const source = this.getSourceFile(file);
-      source?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
-    }
-  };
-  get readFile() {
-    return this.options.readFile;
-  }
-  get getFiles() {
-    return this.options.getFiles;
-  }
-  parseJson = (filePath) => {
-    const { readFile, parserOptions } = this.options;
-    const content = readFile(filePath);
-    parserOptions.encoder.fromJSON(JSON.parse(content));
-    const result = new ParserResult(parserOptions);
-    return result.setFilePath(filePath);
-  };
-  parseSourceFile = (filePath, encoder) => {
-    const { hooks } = this.options;
-    if (filePath.endsWith(".json")) {
-      return this.parseJson(filePath);
-    }
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) return;
-    const original = sourceFile.getText();
-    const options = {};
-    const custom = hooks["parser:before"]?.({
-      filePath,
-      content: original,
-      configure(opts) {
-        const { matchTag, matchTagMode, matchTagProp } = opts;
-        if (matchTag) {
-          options.matchTag = matchTag;
-        }
-        if (matchTagMode) {
-          options.matchTagMode = matchTagMode;
-        }
-        if (matchTagProp) {
-          options.matchTagProp = matchTagProp;
-        }
-      }
-    });
-    const transformed = custom ?? this.transformFile(filePath, original);
-    if (original !== transformed) {
-      sourceFile.replaceWithText(transformed);
-    }
-    if (hooks["parser:preprocess"]) {
-      options.transform = hooks["parser:preprocess"];
-    }
-    const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
-    hooks["parser:after"]?.({ filePath, result });
-    return result;
-  };
-  transformFile = (_filePath, content) => {
-    return content;
-  };
-  classify = (fileMap) => {
-    const { parserOptions } = this.options;
-    return classifyProject(parserOptions, fileMap);
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ParserResult,
-  Project
-});