@pandacss/parser 0.0.0-dev-20221121153631

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Segun Adebayo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { CompilerOptions, Project, SourceFile } from 'ts-morph';
+
+declare type Result = {
+    name?: string;
+    data: Record<string, any>;
+    type?: string;
+};
+declare class Collector {
+    jsx: Set<Result>;
+    css: Set<Result>;
+    globalCss: Set<Result>;
+    cssMap: Set<Result>;
+    recipe: Map<string, Set<Result>>;
+    pattern: Map<string, Set<Result>>;
+    set(name: string, result: {
+        data: Record<string, any>;
+    }): void;
+    setPattern(name: string, result: {
+        data: Record<string, any>;
+    }): void;
+    setRecipe(name: string, result: {
+        data: Record<string, any>;
+    }): void;
+    get isEmpty(): boolean;
+}
+
+declare function createProject(compilerOptions?: Partial<CompilerOptions>): Project;
+declare type ParserOptions = {
+    importMap: Record<'css' | 'recipe' | 'pattern' | 'jsx', string>;
+    jsx?: {
+        factory: string;
+        nodes: Array<{
+            name: string;
+            props?: string[];
+        }>;
+        isStyleProp: (prop: string) => boolean;
+    };
+};
+declare function createParser(options: ParserOptions): (sourceFile: SourceFile | undefined) => Collector | undefined;
+
+export { Collector, createParser, createProject };

package/dist/index.js

@@ -0,0 +1,341 @@
+"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 src_exports = {};
+__export(src_exports, {
+  createParser: () => createParser,
+  createProject: () => createProject
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/parser.ts
+var import_logger = require("@pandacss/logger");
+var import_shared2 = require("@pandacss/shared");
+var import_ts_morph4 = require("ts-morph");
+var import_ts_pattern3 = require("ts-pattern");
+
+// src/call-expression.ts
+var import_ts_morph2 = require("ts-morph");
+
+// src/literal.ts
+var import_ts_morph = require("ts-morph");
+var import_ts_pattern = require("ts-pattern");
+
+// src/strip-quotes.ts
+function stripQuotes(q) {
+  const quoteStart = `'|"|\u2018|\u201C|\u2039|\xAB`;
+  const quoteEnd = `'|"|\u2019|\u201D|\u203A|\xBB`;
+  if (typeof q !== "string")
+    throw new Error(`input was '${typeof q}' and not of type 'string'`);
+  if (!q.length)
+    throw new Error(`input was empty`);
+  let s = q;
+  let t = s.length;
+  if (s.charAt(0).match(new RegExp(quoteStart))) {
+    s = s.substring(1, t--);
+  }
+  if (s.charAt(--t).match(new RegExp(quoteEnd))) {
+    s = s.substring(0, t);
+  }
+  return s;
+}
+
+// src/literal.ts
+function isPrimitiveLiteral(node) {
+  return import_ts_morph.Node.isStringLiteral(node) || import_ts_morph.Node.isNumericLiteral(node) || import_ts_morph.Node.isTrueLiteral(node) || import_ts_morph.Node.isFalseLiteral(node);
+}
+function extractValue(value) {
+  return (0, import_ts_pattern.match)(value).when(isPrimitiveLiteral, (value2) => {
+    return value2.getLiteralValue();
+  }).when(import_ts_morph.Node.isNullLiteral, () => {
+    return null;
+  }).when(import_ts_morph.Node.isObjectLiteralExpression, (value2) => {
+    return extractObjectLiteral(value2);
+  }).when(import_ts_morph.Node.isArrayLiteralExpression, (value2) => {
+    return extractArrayLiteral(value2);
+  }).otherwise(() => {
+    return void 0;
+  });
+}
+function extractObjectLiteral(node) {
+  const data = {};
+  const properties = node.getProperties();
+  for (const property of properties) {
+    if (import_ts_morph.Node.isPropertyAssignment(property)) {
+      const key = stripQuotes(property.getName());
+      const value = property.getInitializer();
+      const returnValue = extractValue(value);
+      if (returnValue !== void 0) {
+        data[key] = returnValue;
+      }
+    }
+  }
+  return data;
+}
+function extractArrayLiteral(node) {
+  const result = [];
+  node.forEachChild((child) => {
+    (0, import_ts_pattern.match)(child).when(isPrimitiveLiteral, (child2) => {
+      result.push(child2.getLiteralValue());
+    }).when(import_ts_morph.Node.isUndefinedKeyword, () => {
+      result.push(void 0);
+    }).when(import_ts_morph.Node.isNullLiteral, () => {
+      result.push(null);
+    }).when(import_ts_morph.Node.isObjectLiteralExpression, (child2) => {
+      result.push(extractObjectLiteral(child2));
+    }).when(import_ts_morph.Node.isArrayLiteralExpression, (child2) => {
+      result.push(extractArrayLiteral(child2));
+    }).otherwise(() => {
+    });
+  });
+  return result;
+}
+
+// src/call-expression.ts
+function visitCallExpressions(file, options) {
+  const { match: match4, fn } = options;
+  const callExpressions = file.getDescendantsOfKind(import_ts_morph2.ts.SyntaxKind.CallExpression);
+  for (const node of callExpressions) {
+    const expr = node.getExpression();
+    const name = expr.getText();
+    if (!match4(name)) {
+      continue;
+    }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      fn({ name, data: {} });
+      continue;
+    }
+    args.forEach((arg) => {
+      if (import_ts_morph2.Node.isObjectLiteralExpression(arg)) {
+        fn({ name, data: extractObjectLiteral(arg) });
+      }
+    });
+  }
+}
+
+// src/collector.ts
+var Collector = class {
+  jsx = /* @__PURE__ */ new Set();
+  css = /* @__PURE__ */ new Set();
+  globalCss = /* @__PURE__ */ new Set();
+  cssMap = /* @__PURE__ */ new Set();
+  recipe = /* @__PURE__ */ new Map();
+  pattern = /* @__PURE__ */ new Map();
+  set(name, result) {
+    this[name].add({ type: "object", ...result });
+  }
+  setPattern(name, result) {
+    this.pattern.get(name) ?? this.pattern.set(name, /* @__PURE__ */ new Set());
+    this.pattern.get(name)?.add({ type: "pattern", name, ...result });
+  }
+  setRecipe(name, result) {
+    this.recipe.get(name) ?? this.recipe.set(name, /* @__PURE__ */ new Set());
+    this.recipe.get(name)?.add({ type: "recipe", ...result });
+  }
+  get isEmpty() {
+    return this.css.size === 0 && this.globalCss.size === 0 && this.cssMap.size === 0 && this.recipe.size === 0 && this.pattern.size === 0 && this.jsx.size === 0;
+  }
+};
+
+// src/import.ts
+var import_shared = require("@pandacss/shared");
+function getImportDeclarations(file, options) {
+  const { match: match4 } = options;
+  const result = [];
+  file.getImportDeclarations().forEach((node) => {
+    const source = node.getModuleSpecifierValue();
+    if (!source)
+      return;
+    const specifiers = node.getNamedImports();
+    specifiers.forEach((specifier) => {
+      const name = specifier.getNameNode().getText();
+      const alias = specifier.getAliasNode()?.getText() || name;
+      if (!match4({ id: name, mod: source }))
+        return;
+      result.push({ name, alias, mod: source });
+    });
+  });
+  return {
+    value: result,
+    toString() {
+      return result.map((item) => item.alias).join(", ");
+    },
+    find(id) {
+      return result.find((o) => o.alias === id);
+    },
+    createMatch(mod) {
+      const mods = result.filter((o) => o.mod.includes(mod));
+      return (0, import_shared.memo)((id) => !!mods.find((mod2) => mod2.alias === id));
+    },
+    match(id) {
+      return !!this.find(id);
+    },
+    getName(id) {
+      return this.find(id)?.name || id;
+    },
+    getAlias(id) {
+      return result.find((o) => o.name === id)?.alias || id;
+    }
+  };
+}
+
+// src/jsx-element.ts
+var import_ts_morph3 = require("ts-morph");
+var import_ts_pattern2 = require("ts-pattern");
+function visitJsxElement(file, options) {
+  const { match: matchProp, fn } = options;
+  const elements = [
+    ...file.getDescendantsOfKind(import_ts_morph3.ts.SyntaxKind.JsxOpeningElement),
+    ...file.getDescendantsOfKind(import_ts_morph3.ts.SyntaxKind.JsxSelfClosingElement)
+  ];
+  for (const node of elements) {
+    const tag = node.getTagNameNode().getText();
+    if (!matchProp.tag(tag))
+      continue;
+    const props = node.getAttributes();
+    const data = {};
+    for (const prop of props) {
+      if (!import_ts_morph3.Node.isJsxAttribute(prop))
+        continue;
+      const name = prop.getName();
+      const value = prop.getInitializer();
+      if (!matchProp.prop({ tag, name }))
+        continue;
+      (0, import_ts_pattern2.match)(value).when(import_ts_morph3.Node.isStringLiteral, (value2) => {
+        data[name] = value2.getLiteralValue();
+      }).when(import_ts_morph3.Node.isJsxExpression, (value2) => {
+        const expr = value2.getExpression();
+        const returnValue = extractValue(expr);
+        if (returnValue !== void 0) {
+          data[name] = returnValue;
+        }
+      }).otherwise(() => {
+        if (!value) {
+          data[name] = true;
+        }
+      });
+    }
+    fn({ name: tag, data });
+  }
+}
+
+// src/parser.ts
+function createProject(compilerOptions = {}) {
+  return new import_ts_morph4.Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true,
+    compilerOptions: {
+      allowJs: true,
+      strictNullChecks: false,
+      skipLibCheck: true,
+      ...compilerOptions
+    }
+  });
+}
+function createImportMatcher(mod, values) {
+  const regex = values ? new RegExp(`^(${values.join("|")})$`) : /.*/;
+  return {
+    mod,
+    regex,
+    match(value) {
+      return regex.test(value);
+    }
+  };
+}
+function createParser(options) {
+  return function parse(sourceFile) {
+    if (!sourceFile)
+      return;
+    const fileName = sourceFile.getFilePath();
+    const collector = new Collector();
+    const { jsx, importMap } = options;
+    const importRegex = [
+      createImportMatcher(importMap.css, ["css", "cssMap", "globalCss"]),
+      createImportMatcher(importMap.recipe),
+      createImportMatcher(importMap.pattern)
+    ];
+    if (jsx) {
+      importRegex.push(createImportMatcher(importMap.jsx, [jsx.factory, ...jsx.nodes.map((node) => node.name)]));
+    }
+    const imports = getImportDeclarations(sourceFile, {
+      match(value) {
+        return importRegex.some(({ regex, mod }) => regex.test(value.id) && value.mod.includes(mod));
+      }
+    });
+    if (imports.value.length) {
+      import_logger.logger.debug({
+        type: "ast:import",
+        msg: `Found import { ${imports} } in ${fileName}`
+      });
+    }
+    const isValidPattern = imports.createMatch(importMap.pattern);
+    const isValidRecipe = imports.createMatch(importMap.recipe);
+    visitCallExpressions(sourceFile, {
+      match: (0, import_shared2.memo)((name) => imports.match(name)),
+      fn({ name: _name, data }) {
+        const name = imports.getName(_name);
+        const [css] = importRegex;
+        const result = { name, data };
+        import_logger.logger.debug({ type: `ast:${name}`, fileName, result });
+        (0, import_ts_pattern3.match)(name).when(css.match, (name2) => {
+          collector.set(name2, result);
+        }).when(isValidPattern, (name2) => {
+          collector.setPattern(name2, result);
+        }).when(isValidRecipe, (name2) => {
+          collector.setRecipe(name2, result);
+        }).otherwise(() => {
+        });
+      }
+    });
+    const jsxFactoryAlias = jsx ? imports.getAlias(jsx.factory) : "panda";
+    const jsxPatternNodes = new RegExp(`(${jsx?.nodes.map((node) => node.name).join("|")})$`);
+    visitJsxElement(sourceFile, {
+      match: {
+        tag: (0, import_shared2.memo)((name) => {
+          return name.startsWith(jsxFactoryAlias) || isUpperCase(name);
+        }),
+        prop: ({ tag, name }) => {
+          const node = jsx?.nodes.find((n) => n.name === tag);
+          return !!jsx?.isStyleProp(name) || !!node?.props?.includes(name);
+        }
+      },
+      fn({ name, data }) {
+        let type;
+        if (jsx && name.startsWith(jsxFactoryAlias)) {
+          type = "jsx-factory";
+        } else if (jsxPatternNodes.test(name)) {
+          type = "pattern";
+        } else {
+          type = "jsx";
+        }
+        collector.jsx.add({ type, name, data });
+      }
+    });
+    return collector;
+  };
+}
+var isUpperCase = (value) => value[0] === value[0].toUpperCase();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createParser,
+  createProject
+});

package/dist/index.mjs

@@ -0,0 +1,315 @@
+// src/parser.ts
+import { logger } from "@pandacss/logger";
+import { memo as memo2 } from "@pandacss/shared";
+import { Project } from "ts-morph";
+import { match as match3 } from "ts-pattern";
+
+// src/call-expression.ts
+import { Node as Node2, ts } from "ts-morph";
+
+// src/literal.ts
+import {
+  Node
+} from "ts-morph";
+import { match } from "ts-pattern";
+
+// src/strip-quotes.ts
+function stripQuotes(q) {
+  const quoteStart = `'|"|\u2018|\u201C|\u2039|\xAB`;
+  const quoteEnd = `'|"|\u2019|\u201D|\u203A|\xBB`;
+  if (typeof q !== "string")
+    throw new Error(`input was '${typeof q}' and not of type 'string'`);
+  if (!q.length)
+    throw new Error(`input was empty`);
+  let s = q;
+  let t = s.length;
+  if (s.charAt(0).match(new RegExp(quoteStart))) {
+    s = s.substring(1, t--);
+  }
+  if (s.charAt(--t).match(new RegExp(quoteEnd))) {
+    s = s.substring(0, t);
+  }
+  return s;
+}
+
+// src/literal.ts
+function isPrimitiveLiteral(node) {
+  return Node.isStringLiteral(node) || Node.isNumericLiteral(node) || Node.isTrueLiteral(node) || Node.isFalseLiteral(node);
+}
+function extractValue(value) {
+  return match(value).when(isPrimitiveLiteral, (value2) => {
+    return value2.getLiteralValue();
+  }).when(Node.isNullLiteral, () => {
+    return null;
+  }).when(Node.isObjectLiteralExpression, (value2) => {
+    return extractObjectLiteral(value2);
+  }).when(Node.isArrayLiteralExpression, (value2) => {
+    return extractArrayLiteral(value2);
+  }).otherwise(() => {
+    return void 0;
+  });
+}
+function extractObjectLiteral(node) {
+  const data = {};
+  const properties = node.getProperties();
+  for (const property of properties) {
+    if (Node.isPropertyAssignment(property)) {
+      const key = stripQuotes(property.getName());
+      const value = property.getInitializer();
+      const returnValue = extractValue(value);
+      if (returnValue !== void 0) {
+        data[key] = returnValue;
+      }
+    }
+  }
+  return data;
+}
+function extractArrayLiteral(node) {
+  const result = [];
+  node.forEachChild((child) => {
+    match(child).when(isPrimitiveLiteral, (child2) => {
+      result.push(child2.getLiteralValue());
+    }).when(Node.isUndefinedKeyword, () => {
+      result.push(void 0);
+    }).when(Node.isNullLiteral, () => {
+      result.push(null);
+    }).when(Node.isObjectLiteralExpression, (child2) => {
+      result.push(extractObjectLiteral(child2));
+    }).when(Node.isArrayLiteralExpression, (child2) => {
+      result.push(extractArrayLiteral(child2));
+    }).otherwise(() => {
+    });
+  });
+  return result;
+}
+
+// src/call-expression.ts
+function visitCallExpressions(file, options) {
+  const { match: match4, fn } = options;
+  const callExpressions = file.getDescendantsOfKind(ts.SyntaxKind.CallExpression);
+  for (const node of callExpressions) {
+    const expr = node.getExpression();
+    const name = expr.getText();
+    if (!match4(name)) {
+      continue;
+    }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      fn({ name, data: {} });
+      continue;
+    }
+    args.forEach((arg) => {
+      if (Node2.isObjectLiteralExpression(arg)) {
+        fn({ name, data: extractObjectLiteral(arg) });
+      }
+    });
+  }
+}
+
+// src/collector.ts
+var Collector = class {
+  jsx = /* @__PURE__ */ new Set();
+  css = /* @__PURE__ */ new Set();
+  globalCss = /* @__PURE__ */ new Set();
+  cssMap = /* @__PURE__ */ new Set();
+  recipe = /* @__PURE__ */ new Map();
+  pattern = /* @__PURE__ */ new Map();
+  set(name, result) {
+    this[name].add({ type: "object", ...result });
+  }
+  setPattern(name, result) {
+    this.pattern.get(name) ?? this.pattern.set(name, /* @__PURE__ */ new Set());
+    this.pattern.get(name)?.add({ type: "pattern", name, ...result });
+  }
+  setRecipe(name, result) {
+    this.recipe.get(name) ?? this.recipe.set(name, /* @__PURE__ */ new Set());
+    this.recipe.get(name)?.add({ type: "recipe", ...result });
+  }
+  get isEmpty() {
+    return this.css.size === 0 && this.globalCss.size === 0 && this.cssMap.size === 0 && this.recipe.size === 0 && this.pattern.size === 0 && this.jsx.size === 0;
+  }
+};
+
+// src/import.ts
+import { memo } from "@pandacss/shared";
+function getImportDeclarations(file, options) {
+  const { match: match4 } = options;
+  const result = [];
+  file.getImportDeclarations().forEach((node) => {
+    const source = node.getModuleSpecifierValue();
+    if (!source)
+      return;
+    const specifiers = node.getNamedImports();
+    specifiers.forEach((specifier) => {
+      const name = specifier.getNameNode().getText();
+      const alias = specifier.getAliasNode()?.getText() || name;
+      if (!match4({ id: name, mod: source }))
+        return;
+      result.push({ name, alias, mod: source });
+    });
+  });
+  return {
+    value: result,
+    toString() {
+      return result.map((item) => item.alias).join(", ");
+    },
+    find(id) {
+      return result.find((o) => o.alias === id);
+    },
+    createMatch(mod) {
+      const mods = result.filter((o) => o.mod.includes(mod));
+      return memo((id) => !!mods.find((mod2) => mod2.alias === id));
+    },
+    match(id) {
+      return !!this.find(id);
+    },
+    getName(id) {
+      return this.find(id)?.name || id;
+    },
+    getAlias(id) {
+      return result.find((o) => o.name === id)?.alias || id;
+    }
+  };
+}
+
+// src/jsx-element.ts
+import { Node as Node3, ts as ts2 } from "ts-morph";
+import { match as match2 } from "ts-pattern";
+function visitJsxElement(file, options) {
+  const { match: matchProp, fn } = options;
+  const elements = [
+    ...file.getDescendantsOfKind(ts2.SyntaxKind.JsxOpeningElement),
+    ...file.getDescendantsOfKind(ts2.SyntaxKind.JsxSelfClosingElement)
+  ];
+  for (const node of elements) {
+    const tag = node.getTagNameNode().getText();
+    if (!matchProp.tag(tag))
+      continue;
+    const props = node.getAttributes();
+    const data = {};
+    for (const prop of props) {
+      if (!Node3.isJsxAttribute(prop))
+        continue;
+      const name = prop.getName();
+      const value = prop.getInitializer();
+      if (!matchProp.prop({ tag, name }))
+        continue;
+      match2(value).when(Node3.isStringLiteral, (value2) => {
+        data[name] = value2.getLiteralValue();
+      }).when(Node3.isJsxExpression, (value2) => {
+        const expr = value2.getExpression();
+        const returnValue = extractValue(expr);
+        if (returnValue !== void 0) {
+          data[name] = returnValue;
+        }
+      }).otherwise(() => {
+        if (!value) {
+          data[name] = true;
+        }
+      });
+    }
+    fn({ name: tag, data });
+  }
+}
+
+// src/parser.ts
+function createProject(compilerOptions = {}) {
+  return new Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true,
+    compilerOptions: {
+      allowJs: true,
+      strictNullChecks: false,
+      skipLibCheck: true,
+      ...compilerOptions
+    }
+  });
+}
+function createImportMatcher(mod, values) {
+  const regex = values ? new RegExp(`^(${values.join("|")})$`) : /.*/;
+  return {
+    mod,
+    regex,
+    match(value) {
+      return regex.test(value);
+    }
+  };
+}
+function createParser(options) {
+  return function parse(sourceFile) {
+    if (!sourceFile)
+      return;
+    const fileName = sourceFile.getFilePath();
+    const collector = new Collector();
+    const { jsx, importMap } = options;
+    const importRegex = [
+      createImportMatcher(importMap.css, ["css", "cssMap", "globalCss"]),
+      createImportMatcher(importMap.recipe),
+      createImportMatcher(importMap.pattern)
+    ];
+    if (jsx) {
+      importRegex.push(createImportMatcher(importMap.jsx, [jsx.factory, ...jsx.nodes.map((node) => node.name)]));
+    }
+    const imports = getImportDeclarations(sourceFile, {
+      match(value) {
+        return importRegex.some(({ regex, mod }) => regex.test(value.id) && value.mod.includes(mod));
+      }
+    });
+    if (imports.value.length) {
+      logger.debug({
+        type: "ast:import",
+        msg: `Found import { ${imports} } in ${fileName}`
+      });
+    }
+    const isValidPattern = imports.createMatch(importMap.pattern);
+    const isValidRecipe = imports.createMatch(importMap.recipe);
+    visitCallExpressions(sourceFile, {
+      match: memo2((name) => imports.match(name)),
+      fn({ name: _name, data }) {
+        const name = imports.getName(_name);
+        const [css] = importRegex;
+        const result = { name, data };
+        logger.debug({ type: `ast:${name}`, fileName, result });
+        match3(name).when(css.match, (name2) => {
+          collector.set(name2, result);
+        }).when(isValidPattern, (name2) => {
+          collector.setPattern(name2, result);
+        }).when(isValidRecipe, (name2) => {
+          collector.setRecipe(name2, result);
+        }).otherwise(() => {
+        });
+      }
+    });
+    const jsxFactoryAlias = jsx ? imports.getAlias(jsx.factory) : "panda";
+    const jsxPatternNodes = new RegExp(`(${jsx?.nodes.map((node) => node.name).join("|")})$`);
+    visitJsxElement(sourceFile, {
+      match: {
+        tag: memo2((name) => {
+          return name.startsWith(jsxFactoryAlias) || isUpperCase(name);
+        }),
+        prop: ({ tag, name }) => {
+          const node = jsx?.nodes.find((n) => n.name === tag);
+          return !!jsx?.isStyleProp(name) || !!node?.props?.includes(name);
+        }
+      },
+      fn({ name, data }) {
+        let type;
+        if (jsx && name.startsWith(jsxFactoryAlias)) {
+          type = "jsx-factory";
+        } else if (jsxPatternNodes.test(name)) {
+          type = "pattern";
+        } else {
+          type = "jsx";
+        }
+        collector.jsx.add({ type, name, data });
+      }
+    });
+    return collector;
+  };
+}
+var isUpperCase = (value) => value[0] === value[0].toUpperCase();
+export {
+  createParser,
+  createProject
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pandacss/parser",
+  "version": "0.0.0-dev-20221121153631",
+  "description": "The static parser for panda css",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "author": "Segun Adebayo <joseshegs@gmail.com>",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ts-pattern": "4.0.6",
+    "ts-morph": "16.0.0",
+    "@pandacss/logger": "0.0.0-dev-20221121153631",
+    "@pandacss/shared": "0.0.0-dev-20221121153631",
+    "@pandacss/is-valid-prop": "0.0.0-dev-20221121153631",
+    "@pandacss/types": "0.0.0-dev-20221121153631"
+  },
+  "devDependencies": {
+    "@pandacss/fixture": "0.0.0-dev-20221121153631"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format=esm,cjs --dts",
+    "build-fast": "tsup src/index.ts --format=esm,cjs --no-dts",
+    "dev": "pnpm build-fast --watch"
+  }
+}