@pandacss/generator 0.7.0 → 0.9.0

package/dist/index.js

@@ -419,7 +419,7 @@ var generateStaticCss = (ctx) => {
         return [];
       return Object.keys(values);
     },
-    getRecipeKeys: (recipe) => recipes.details.find((detail) => detail.config.name === recipe)?.variantKeyMap ?? {}
+    getRecipeKeys: (recipe) => recipes.details.find((detail) => detail.baseName === recipe)?.variantKeyMap ?? {}
   });
   results.css.forEach((css2) => {
     sheet.processAtomic(css2);
@@ -429,7 +429,7 @@ var generateStaticCss = (ctx) => {
       const recipeConfig = recipes.getConfig(name);
       if (!recipeConfig)
         return;
-      sheet.processRecipe(recipeConfig, value);
+      sheet.processRecipe(name, recipeConfig, value);
     });
   });
   const output = sheet.toCss({ optimize });
@@ -624,16 +624,22 @@ function generateCssFn(ctx) {
   return {
     dts: import_outdent4.outdent`
     import type { SystemStyleObject } from '../types'
-    export declare function css(styles: SystemStyleObject): string
+
+    interface CssFunction {
+      (styles: SystemStyleObject): string
+      raw: (styles: SystemStyleObject) => SystemStyleObject
+    }
+
+    export declare const css: CssFunction;
     `,
     js: import_outdent4.outdent`
     ${ctx.file.import("createCss, createMergeCss, hypenateProperty, withoutSpace", "../helpers")}
     ${ctx.file.import("sortConditions, finalizeConditions", "./conditions")}
 
     const classNameMap = ${stringify(utility.entries())}
-    
+
     const shorthands = ${stringify(utility.shorthands)}
-    
+
     const breakpointKeys = ${JSON.stringify(conditions.breakpoints.keys)}
 
     const hasShorthand = ${utility.hasShorthand ? "true" : "false"}
@@ -663,6 +669,7 @@ function generateCssFn(ctx) {
     }
 
     export const css = createCss(context)
+    css.raw = (styles) => styles
 
     export const { mergeCss, assignCss } = createMergeCss(context)
     `
@@ -886,7 +893,7 @@ function generatePattern(ctx) {
   if (ctx.patterns.isEmpty())
     return;
   return ctx.patterns.details.map((pattern) => {
-    const { name, config, dashName, upperName, styleFnName, blocklistType } = pattern;
+    const { baseName, config, dashName, upperName, styleFnName, blocklistType } = pattern;
     const { properties, transform, strict, description } = config;
     const transformFn = (0, import_javascript_stringify.stringify)({ transform }) ?? "";
     const helperImports = ["mapObject"];
@@ -922,12 +929,17 @@ function generatePattern(ctx) {
       }).join("\n	")}
       }
 
-      ${strict ? import_outdent10.outdent`export declare function ${name}(options: ${upperName}Properties): string` : import_outdent10.outdent`
+      ${strict ? import_outdent10.outdent`export declare function ${baseName}(options: ${upperName}Properties): string` : import_outdent10.outdent`
 
           type ${upperName}Options = ${upperName}Properties & Omit<SystemStyleObject, keyof ${upperName}Properties ${blocklistType}>
 
+          interface ${upperName}PatternFn {
+            (options?: ${upperName}Options): string
+            raw: (options: ${upperName}Options) => ${upperName}Options
+          }
+
           ${description ? `/** ${description} */` : ""}
-          export declare function ${name}(options?: ${upperName}Options): string
+          export declare const ${baseName}: ${upperName}PatternFn;
           `}
 
      `,
@@ -935,12 +947,13 @@ function generatePattern(ctx) {
     ${ctx.file.import(helperImports.join(", "), "../helpers")}
     ${ctx.file.import("css", "../css/index")}
 
-    const ${name}Config = ${transformFn.replace(`{transform`, `{
+    const ${baseName}Config = ${transformFn.replace(`{transform`, `{
 transform`)}
 
-    export const ${styleFnName} = (styles = {}) => ${name}Config.transform(styles, { map: mapObject })
+    export const ${styleFnName} = (styles = {}) => ${baseName}Config.transform(styles, { map: mapObject })
 
-    export const ${name} = (styles) => css(${styleFnName}(styles))
+    export const ${baseName} = (styles) => css(${styleFnName}(styles))
+    ${baseName}.raw = (styles) => styles
     `
     };
   });
@@ -1005,29 +1018,26 @@ function generateRecipes(ctx) {
   return [
     createRecipeFn,
     ...ctx.recipes.details.map((recipe) => {
-      const { config, upperName, variantKeyMap, dashName } = recipe;
-      const { name, description, defaultVariants, compoundVariants } = config;
+      const { baseName, config, upperName, variantKeyMap, dashName } = recipe;
+      const { description, defaultVariants, compoundVariants } = config;
       return {
         name: dashName,
         js: import_outdent11.outdent`
         ${ctx.file.import("splitProps", "../helpers")}
         ${ctx.file.import("createRecipe", "./create-recipe")}
 
-        const ${name}Fn = createRecipe('${name}', ${stringify3(defaultVariants ?? {})}, ${stringify3(
+        const ${baseName}Fn = createRecipe('${baseName}', ${stringify3(defaultVariants ?? {})}, ${stringify3(
           compoundVariants ?? []
         )})
 
-        const variantKeys = ${stringify3(Object.keys(variantKeyMap))}
-
-        function splitVariantProps(props) {
-          return splitProps(props, variantKeys)
-        }
-        
-        export const ${name} = Object.assign(${name}Fn, {
+        export const ${baseName} = Object.assign(${baseName}Fn, {
           __recipe__: true,
-          variantKeys,
+          raw: (props) => props,
+          variantKeys: ${stringify3(Object.keys(variantKeyMap))},
           variantMap: ${stringify3(variantKeyMap)},
-          splitVariantProps,
+          splitVariantProps(props) {
+            return splitProps(props, ${stringify3(Object.keys(variantKeyMap))})
+          },
         })
         `,
         dts: import_outdent11.outdent`
@@ -1054,13 +1064,14 @@ function generateRecipes(ctx) {
         interface ${upperName}Recipe {
           __type: ${upperName}VariantProps
           (props?: ${upperName}VariantProps): string
+          raw: (props?: ${upperName}VariantProps) => ${upperName}VariantProps
           variantMap: ${upperName}VariantMap
           variantKeys: Array<keyof ${upperName}Variant>
           splitVariantProps<Props extends ${upperName}VariantProps>(props: Props): [${upperName}VariantProps, Pretty<Omit<Props, keyof ${upperName}VariantProps>>]
         }
 
         ${description ? `/** ${description} */` : ""}
-        export declare const ${name}: ${upperName}Recipe
+        export declare const ${baseName}: ${upperName}Recipe
         `
       };
     })
@@ -1741,12 +1752,16 @@ import { ${upperName} } from '../types/jsx'
 export declare const ${factoryName}: ${upperName}
     `,
     jsxType: import_outdent25.outdent`
-import type { ComponentProps, ElementType } from 'react'
+import type { ComponentPropsWithoutRef, ElementType, ElementRef, Ref } from 'react'
 import type { Assign, JsxStyleProps, JsxHTMLProps } from './system-types'
 import type { RecipeDefinition, RecipeSelection, RecipeVariantRecord } from './recipe'
 
 type Dict = Record<string, unknown>
 
+type ComponentProps<T extends ElementType> = Omit<ComponentPropsWithoutRef<T>, 'ref'> & {
+  ref?: Ref<ElementRef<T>>
+}
+
 export type ${componentName}<T extends ElementType, P extends Dict = {}> = {
   (props: JsxHTMLProps<ComponentProps<T>, Assign<JsxStyleProps, P>>): JSX.Element
   displayName?: string
@@ -1832,10 +1847,14 @@ import { ${upperName} } from '../types/jsx'
 export declare const ${factoryName}: ${upperName}
     `,
     jsxType: import_outdent27.outdent`
-import type { ComponentProps, ElementType } from 'react'
+import type { ComponentPropsWithoutRef, ElementType, ElementRef, Ref } from 'react'
 
 type Dict = Record<string, unknown>
 
+type ComponentProps<T extends ElementType> = Omit<ComponentPropsWithoutRef<T>, 'ref'> & {
+  ref?: Ref<ElementRef<T>>
+}
+
 export type ${componentName}<T extends ElementType> = {
   (args: { raw: readonly string[] | ArrayLike<string> }): (props: ComponentProps<T>) => JSX.Element
   displayName?: string
@@ -2667,38 +2686,38 @@ function generateJsxPatterns(ctx) {
 // src/artifacts/pkg-json.ts
 function generatePackageJson(ctx) {
   const {
-    config: { outdir }
+    config: { outdir, outExtension: ext = "mjs" }
   } = ctx;
   const pkg = {
     name: outdir,
-    description: "This package is auto-generated by CSS Panda",
+    description: "This package is auto-generated by Panda CSS",
     version: `0.0.0-${performance.now()}`,
     type: "module",
     exports: {
       "./css": {
         types: "./css/index.d.ts",
-        require: "./css/index.mjs",
-        import: "./css/index.mjs"
+        require: `./css/index.${ext}`,
+        import: `./css/index.${ext}`
       },
       "./jsx": {
         types: "./jsx/index.d.ts",
-        require: "./jsx/index.mjs",
-        import: "./jsx/index.mjs"
+        require: `./jsx/index.${ext}`,
+        import: `./jsx/index.${ext}`
       },
       "./patterns": {
         types: "./patterns/index.d.ts",
-        require: "./patterns/index.mjs",
-        import: "./patterns/index.mjs"
+        require: `./patterns/index.${ext}`,
+        import: `./patterns/index.${ext}`
       },
       "./recipes": {
         types: "./recipes/index.d.ts",
-        require: "./recipes/index.mjs",
-        import: "./recipes/index.mjs"
+        require: `./recipes/index.${ext}`,
+        import: `./recipes/index.${ext}`
       },
       "./tokens": {
         types: "./tokens/index.d.ts",
-        require: "./tokens/index.mjs",
-        import: "./tokens/index.mjs"
+        require: `./tokens/index.${ext}`,
+        import: `./tokens/index.${ext}`
       },
       "./types": {
         types: "./types/index.d.ts"
@@ -2726,12 +2745,12 @@ var composition_d_ts_default = {
 
 // src/artifacts/generated/recipe.d.ts.json
 var recipe_d_ts_default = {
-  content: "import type { SystemStyleObject } from './system-types'\n\ntype Pretty<T> = T extends infer U ? { [K in keyof U]: U[K] } : never\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T\n\nexport type RecipeVariantRecord = Record<any, Record<any, SystemStyleObject>>\n\nexport type RecipeSelection<T extends RecipeVariantRecord> = keyof any extends keyof T\n  ? {}\n  : {\n      [K in keyof T]?: StringToBoolean<keyof T[K]>\n    }\n\nexport type RecipeVariantFn<T extends RecipeVariantRecord> = (props?: RecipeSelection<T>) => string\n\nexport type RecipeVariantProps<T extends RecipeVariantFn<RecipeVariantRecord>> = Pretty<Parameters<T>[0]>\n\ntype RecipeVariantMap<T extends RecipeVariantRecord> = {\n  [K in keyof T]: Array<keyof T[K]>\n}\n\nexport type RecipeRuntimeFn<T extends RecipeVariantRecord> = RecipeVariantFn<T> & {\n  __type: RecipeSelection<T>\n  variantKeys: (keyof T)[]\n  variantMap: RecipeVariantMap<T>\n  resolve: (props: RecipeSelection<T>) => SystemStyleObject\n  config: RecipeConfig<T>\n  splitVariantProps<Props extends RecipeSelection<T>>(props: Props): [RecipeSelection<T>, Pretty<Omit<Props, keyof T>>]\n}\n\nexport type RecipeCompoundSelection<T extends RecipeVariantRecord> = {\n  [K in keyof T]?: StringToBoolean<keyof T[K]> | Array<StringToBoolean<keyof T[K]>>\n}\n\nexport type RecipeCompoundVariant<T extends RecipeVariantRecord> = RecipeCompoundSelection<T> & {\n  css: SystemStyleObject\n}\n\nexport type RecipeDefinition<T extends RecipeVariantRecord> = {\n  /**\n   * The base styles of the recipe.\n   */\n  base?: SystemStyleObject\n  /**\n   * The multi-variant styles of the recipe.\n   */\n  variants?: T | RecipeVariantRecord\n  /**\n   * The default variants of the recipe.\n   */\n  defaultVariants?: RecipeSelection<T>\n  /**\n   * The styles to apply when a combination of variants is selected.\n   */\n  compoundVariants?: Array<RecipeCompoundVariant<T>>\n}\n\nexport type RecipeCreatorFn = <T extends RecipeVariantRecord>(config: RecipeDefinition<T>) => RecipeRuntimeFn<T>\n\nexport type RecipeConfig<T extends RecipeVariantRecord = RecipeVariantRecord> = RecipeDefinition<T> & {\n  /**\n   * The name of the recipe.\n   */\n  name: string\n  /**\n   * The description of the recipe. This will be used in the JSDoc comment.\n   */\n  description?: string\n  /**\n   * The jsx elements to track for this recipe. Can be string or Regexp.\n   *\n   * @default capitalize(recipe.name)\n   * @example ['Button', 'Link', /Button$/]\n   */\n  jsx?: Array<string | RegExp>\n}\n"
+  content: "import type { SystemStyleObject } from './system-types'\n\ntype Pretty<T> = T extends infer U ? { [K in keyof U]: U[K] } : never\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T\n\nexport type RecipeVariantRecord = Record<any, Record<any, SystemStyleObject>>\n\nexport type RecipeSelection<T extends RecipeVariantRecord> = keyof any extends keyof T\n  ? {}\n  : {\n      [K in keyof T]?: StringToBoolean<keyof T[K]>\n    }\n\nexport type RecipeVariantFn<T extends RecipeVariantRecord> = (props?: RecipeSelection<T>) => string\n\nexport type RecipeVariantProps<T extends RecipeVariantFn<RecipeVariantRecord>> = Pretty<Parameters<T>[0]>\n\ntype RecipeVariantMap<T extends RecipeVariantRecord> = {\n  [K in keyof T]: Array<keyof T[K]>\n}\n\nexport type RecipeRuntimeFn<T extends RecipeVariantRecord> = RecipeVariantFn<T> & {\n  __type: RecipeSelection<T>\n  variantKeys: (keyof T)[]\n  variantMap: RecipeVariantMap<T>\n  resolve: (props: RecipeSelection<T>) => SystemStyleObject\n  config: RecipeConfig<T>\n  splitVariantProps<Props extends RecipeSelection<T>>(props: Props): [RecipeSelection<T>, Pretty<Omit<Props, keyof T>>]\n}\n\nexport type RecipeCompoundSelection<T extends RecipeVariantRecord> = {\n  [K in keyof T]?: StringToBoolean<keyof T[K]> | Array<StringToBoolean<keyof T[K]>>\n}\n\nexport type RecipeCompoundVariant<T extends RecipeVariantRecord> = RecipeCompoundSelection<T> & {\n  css: SystemStyleObject\n}\n\nexport type RecipeDefinition<T extends RecipeVariantRecord> = {\n  /**\n   * The base styles of the recipe.\n   */\n  base?: SystemStyleObject\n  /**\n   * The multi-variant styles of the recipe.\n   */\n  variants?: T | RecipeVariantRecord\n  /**\n   * The default variants of the recipe.\n   */\n  defaultVariants?: RecipeSelection<T>\n  /**\n   * The styles to apply when a combination of variants is selected.\n   */\n  compoundVariants?: Array<RecipeCompoundVariant<T>>\n}\n\nexport type RecipeCreatorFn = <T extends RecipeVariantRecord>(config: RecipeDefinition<T>) => RecipeRuntimeFn<T>\n\nexport type RecipeConfig<T extends RecipeVariantRecord = RecipeVariantRecord> = RecipeDefinition<T> & {\n  /**\n   * The name of the recipe.\n   */\n  className: string\n  /**\n   * The description of the recipe. This will be used in the JSDoc comment.\n   */\n  description?: string\n  /**\n   * The jsx elements to track for this recipe. Can be string or Regexp.\n   *\n   * @default capitalize(recipe.name)\n   * @example ['Button', 'Link', /Button$/]\n   */\n  jsx?: Array<string | RegExp>\n}\n"
 };
 
 // src/artifacts/generated/pattern.d.ts.json
 var pattern_d_ts_default = {
-  content: "import type { CssProperty, SystemStyleObject } from './system-types'\nimport type { TokenCategory } from '../tokens'\n\ntype Primitive = string | number | boolean | null | undefined\ntype LiteralUnion<T, K extends Primitive = string> = T | (K & Record<never, never>)\n\nexport type PatternProperty =\n  | { type: 'property'; value: CssProperty }\n  | { type: 'enum'; value: string[] }\n  | { type: 'token'; value: TokenCategory; property?: CssProperty }\n  | { type: 'string' | 'boolean' | 'number' }\n\nexport type PatternHelpers = {\n  map: (value: any, fn: (value: string) => string | undefined) => any\n}\n\nexport type PatternProperties = Record<string, PatternProperty>\n\ntype Props<T> = Record<LiteralUnion<keyof T>, any>\n\nexport type PatternConfig<T extends PatternProperties = PatternProperties> = {\n  /**\n   * The description of the pattern. This will be used in the JSDoc comment.\n   */\n  description?: string\n  /**\n   * The JSX element rendered by the pattern\n   * @default 'div'\n   */\n  jsxElement?: string\n  /**\n   * The properties of the pattern.\n   */\n  properties?: T\n  /**\n   * The css object this pattern will generate.\n   */\n  transform?: (props: Props<T>, helpers: PatternHelpers) => SystemStyleObject\n  /**\n   * The jsx element name this pattern will generate.\n   */\n  jsx?: string\n  /**\n   * Whether to only generate types for the specified properties.\n   * This will disallow css properties\n   */\n  strict?: boolean\n  /**\n   * @experimental\n   * Disallow certain css properties for this pattern\n   */\n  blocklist?: LiteralUnion<CssProperty>[]\n}\n"
+  content: "import type { CssProperty, SystemStyleObject } from './system-types'\nimport type { TokenCategory } from '../tokens'\n\ntype Primitive = string | number | boolean | null | undefined\ntype LiteralUnion<T, K extends Primitive = string> = T | (K & Record<never, never>)\n\nexport type PatternProperty =\n  | { type: 'property'; value: CssProperty }\n  | { type: 'enum'; value: string[] }\n  | { type: 'token'; value: TokenCategory; property?: CssProperty }\n  | { type: 'string' | 'boolean' | 'number' }\n\nexport type PatternHelpers = {\n  map: (value: any, fn: (value: string) => string | undefined) => any\n}\n\nexport type PatternProperties = Record<string, PatternProperty>\n\ntype Props<T> = Record<LiteralUnion<keyof T>, any>\n\nexport type PatternConfig<T extends PatternProperties = PatternProperties> = {\n  /**\n   * The description of the pattern. This will be used in the JSDoc comment.\n   */\n  description?: string\n  /**\n   * The JSX element rendered by the pattern\n   * @default 'div'\n   */\n  jsxElement?: string\n  /**\n   * The properties of the pattern.\n   */\n  properties?: T\n  /**\n   * The css object this pattern will generate.\n   */\n  transform?: (props: Props<T>, helpers: PatternHelpers) => SystemStyleObject\n  /**\n   * The jsx element name this pattern will generate.\n   */\n  jsxName?: string\n  /**\n   * The jsx elements to track for this pattern. Can be string or Regexp.\n   *\n   * @default capitalize(pattern.name)\n   * @example ['Button', 'Link', /Button$/]\n   */\n  jsx?: Array<string | RegExp>\n  /**\n   * Whether to only generate types for the specified properties.\n   * This will disallow css properties\n   */\n  strict?: boolean\n  /**\n   * @experimental\n   * Disallow certain css properties for this pattern\n   */\n  blocklist?: LiteralUnion<CssProperty>[]\n}\n"
 };
 
 // src/artifacts/generated/parts.d.ts.json
@@ -3185,21 +3204,21 @@ var generateParserCss = (ctx) => (result) => (0, import_func.pipe)(
         sheet.processStyleProps(data);
       });
     });
-    result2.recipe.forEach((recipeSet, name) => {
+    result2.recipe.forEach((recipeSet, recipeName) => {
       try {
         for (const recipe of recipeSet) {
-          const recipeConfig = recipes.getConfig(name);
+          const recipeConfig = recipes.getConfig(recipeName);
           if (!recipeConfig)
             continue;
-          (0, import_ts_pattern6.match)(recipe).with({ type: "jsx-recipe", name: import_ts_pattern6.P.string }, ({ name: name2 }) => {
+          (0, import_ts_pattern6.match)(recipe).with({ type: "jsx-recipe" }, () => {
             recipe.data.forEach((data) => {
-              const [recipeProps, styleProps] = recipes.splitProps(name2, data);
+              const [recipeProps, styleProps] = recipes.splitProps(recipeName, data);
               sheet.processStyleProps(styleProps);
-              sheet.processRecipe(recipeConfig, recipeProps);
+              sheet.processRecipe(recipeName, recipeConfig, recipeProps);
             });
           }).otherwise(() => {
             recipe.data.forEach((data) => {
-              sheet.processRecipe(recipeConfig, data);
+              sheet.processRecipe(recipeName, recipeConfig, data);
             });
           });
         }
@@ -3210,9 +3229,9 @@ var generateParserCss = (ctx) => (result) => (0, import_func.pipe)(
     result2.pattern.forEach((patternSet, name) => {
       try {
         for (const pattern of patternSet) {
-          (0, import_ts_pattern6.match)(pattern).with({ type: "jsx-pattern", name: import_ts_pattern6.P.string }, ({ name: name2 }) => {
+          (0, import_ts_pattern6.match)(pattern).with({ type: "jsx-pattern", name: import_ts_pattern6.P.string }, ({ name: jsxName }) => {
             pattern.data.forEach((data) => {
-              const fnName = patterns.getFnName(name2);
+              const fnName = patterns.getFnName(jsxName);
               const styleProps = patterns.transform(fnName, data);
               sheet.processStyleProps(styleProps);
             });
@@ -3362,52 +3381,51 @@ var getPathEngine = ({ cwd, emitPackage, outdir }) => {
 
 // src/engines/pattern.ts
 var import_shared7 = require("@pandacss/shared");
-var import_lil_fp2 = require("lil-fp");
 var helpers2 = { map: import_shared7.mapObject };
+var createRegex = (item) => {
+  const regex = item.map((item2) => typeof item2 === "string" ? item2 : item2.source).join("|");
+  return new RegExp(`^${regex}$`);
+};
 var getPatternEngine = (config) => {
-  return (0, import_lil_fp2.pipe)(
-    { patterns: config.patterns ?? {} },
-    import_lil_fp2.Obj.bind("getConfig", ({ patterns }) => {
-      return (name) => patterns[name];
-    }),
-    import_lil_fp2.Obj.bind("transform", ({ getConfig }) => {
-      return (name, data) => {
-        return getConfig(name)?.transform?.(data, helpers2) ?? {};
-      };
-    }),
-    import_lil_fp2.Obj.bind("getNames", ({ getConfig }) => (name) => {
-      const upperName = (0, import_shared7.capitalize)(name);
-      return {
-        name,
-        upperName,
-        dashName: (0, import_shared7.dashCase)(name),
-        styleFnName: `get${upperName}Style`,
-        jsxName: getConfig(name)?.jsx ?? upperName
-      };
-    }),
-    import_lil_fp2.Obj.bind("details", ({ getNames, patterns }) => {
-      return Object.entries(patterns).map(([name, pattern]) => ({
-        ...getNames(name),
-        props: Object.keys(pattern?.properties ?? {}),
-        blocklistType: pattern?.blocklist ? `| '${pattern.blocklist.join("' | '")}'` : "",
-        config: pattern
-      }));
-    }),
-    import_lil_fp2.Obj.bind("nodes", ({ patterns }) => {
-      return Object.entries(patterns).map(([name, pattern]) => ({
-        type: "pattern",
-        name: pattern.jsx ?? (0, import_shared7.capitalize)(name),
-        props: Object.keys(pattern?.properties ?? {}),
-        baseName: name
-      }));
+  const patterns = config.patterns ?? {};
+  const getNames = (name) => {
+    const upperName = (0, import_shared7.capitalize)(name);
+    return {
+      upperName,
+      baseName: name,
+      dashName: (0, import_shared7.dashCase)(name),
+      styleFnName: `get${upperName}Style`,
+      jsxName: patterns[name]?.jsxName ?? upperName
+    };
+  };
+  const details = Object.entries(patterns).map(([name, pattern]) => {
+    const names = getNames(name);
+    const jsx = (pattern.jsx ?? []).concat([names.jsxName]);
+    return {
+      ...names,
+      props: Object.keys(pattern?.properties ?? {}),
+      blocklistType: pattern?.blocklist ? `| '${pattern.blocklist.join("' | '")}'` : "",
+      config: pattern,
+      type: "pattern",
+      match: createRegex(jsx),
+      jsx
+    };
+  });
+  return {
+    getConfig: (name) => patterns[name],
+    transform: (name, data) => {
+      return patterns[name]?.transform?.(data, helpers2) ?? {};
+    },
+    getNames,
+    details,
+    getFnName: (0, import_shared7.memo)((jsxName) => {
+      return details.find((node) => node.jsxName === jsxName)?.baseName ?? (0, import_shared7.uncapitalize)(jsxName);
     }),
-    import_lil_fp2.Obj.bind("getFnName", ({ nodes }) => (jsx) => {
-      return nodes.find((node) => node.name === jsx)?.baseName ?? (0, import_shared7.uncapitalize)(jsx);
+    filter: (0, import_shared7.memo)((jsxName) => {
+      return details.filter((node) => node.match.test(jsxName));
     }),
-    import_lil_fp2.Obj.bind("isEmpty", ({ patterns }) => {
-      return () => Object.keys(patterns).length === 0;
-    })
-  );
+    isEmpty: () => Object.keys(patterns).length === 0
+  };
 };
 
 // src/engines/index.ts
@@ -3442,10 +3460,10 @@ var defaults = (conf) => ({
   }
 });
 var getImportMap = (outdir) => ({
-  css: `${outdir}/css`,
-  recipe: `${outdir}/recipes`,
-  pattern: `${outdir}/patterns`,
-  jsx: `${outdir}/jsx`
+  css: [outdir, "css"],
+  recipe: [outdir, "recipes"],
+  pattern: [outdir, "patterns"],
+  jsx: [outdir, "jsx"]
 });
 var createGenerator = (conf) => {
   const ctx = getEngine(defaults(conf));
@@ -3453,7 +3471,7 @@ var createGenerator = (conf) => {
   const compilerOptions = conf.tsconfig?.compilerOptions ?? {};
   const baseUrl = compilerOptions.baseUrl ?? "";
   const cwd = conf.config.cwd;
-  const relativeBaseUrl = baseUrl ? baseUrl.replace(cwd, "").slice(1) + "/" : cwd;
+  const relativeBaseUrl = baseUrl !== cwd ? baseUrl.replace(cwd, "").slice(1) : cwd;
   return {
     ...ctx,
     getArtifacts: generateArtifacts(ctx),
@@ -3465,9 +3483,12 @@ var createGenerator = (conf) => {
       jsx: {
         factory: jsx.factoryName,
         isStyleProp: isValidProperty,
-        nodes: [...patterns.nodes, ...recipes.nodes]
+        nodes: [...patterns.details, ...recipes.details]
       },
-      getRecipesByJsxName: recipes.filter
+      getRecipesByJsxName: recipes.filter,
+      getPatternsByJsxName: patterns.filter,
+      compilerOptions,
+      tsOptions: conf.tsOptions
     }
   };
 };