@pandacss/node 0.0.2 → 0.3.0

package/dist/index.js

@@ -33,83 +33,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.4/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@6.7.0_postcss@8.4.24_typescript@5.1.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.4/node_modules/tsup/assets/cjs_shims.js"() {
-  }
-});
-
-// ../../node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js
-var require_duplexer = __commonJS({
-  "../../node_modules/.pnpm/duplexer@0.1.2/node_modules/duplexer/index.js"(exports, module2) {
-    init_cjs_shims();
-    var Stream = require("stream");
-    var writeMethods = ["write", "end", "destroy"];
-    var readMethods = ["resume", "pause"];
-    var readEvents = ["data", "close"];
-    var slice = Array.prototype.slice;
-    module2.exports = duplex;
-    function forEach(arr, fn) {
-      if (arr.forEach) {
-        return arr.forEach(fn);
-      }
-      for (var i = 0; i < arr.length; i++) {
-        fn(arr[i], i);
-      }
-    }
-    function duplex(writer, reader) {
-      var stream2 = new Stream();
-      var ended = false;
-      forEach(writeMethods, proxyWriter);
-      forEach(readMethods, proxyReader);
-      forEach(readEvents, proxyStream);
-      reader.on("end", handleEnd);
-      writer.on("drain", function() {
-        stream2.emit("drain");
-      });
-      writer.on("error", reemit);
-      reader.on("error", reemit);
-      stream2.writable = writer.writable;
-      stream2.readable = reader.readable;
-      return stream2;
-      function proxyWriter(methodName) {
-        stream2[methodName] = method;
-        function method() {
-          return writer[methodName].apply(writer, arguments);
-        }
-      }
-      function proxyReader(methodName) {
-        stream2[methodName] = method;
-        function method() {
-          stream2.emit(methodName);
-          var func = reader[methodName];
-          if (func) {
-            return func.apply(reader, arguments);
-          }
-          reader.emit(methodName);
-        }
-      }
-      function proxyStream(methodName) {
-        reader.on(methodName, reemit2);
-        function reemit2() {
-          var args = slice.call(arguments);
-          args.unshift(methodName);
-          stream2.emit.apply(stream2, args);
-        }
-      }
-      function handleEnd() {
-        if (ended) {
-          return;
-        }
-        ended = true;
-        var args = slice.call(arguments);
-        args.unshift("end");
-        stream2.emit.apply(stream2, args);
-      }
-      function reemit(err) {
-        stream2.emit("error", err);
-      }
-    }
+  "../../node_modules/.pnpm/tsup@6.7.0_postcss@8.4.24_typescript@5.1.3/node_modules/tsup/assets/cjs_shims.js"() {
   }
 });
 
@@ -484,11 +410,15 @@ __export(src_exports, {
   emitArtifacts: () => emitArtifacts,
   execCommand: () => execCommand,
   extractCss: () => extractCss,
+  extractFile: () => extractFile,
+  findConfig: () => findConfig,
   generate: () => generate,
   loadConfigAndCreateContext: () => loadConfigAndCreateContext,
+  parseDependency: () => parseDependency,
   setupConfig: () => setupConfig,
   setupGitIgnore: () => setupGitIgnore,
   setupPostcss: () => setupPostcss,
+  shipFiles: () => shipFiles,
   writeAnalyzeJSON: () => writeAnalyzeJSON
 });
 module.exports = __toCommonJS(src_exports);
@@ -498,8 +428,9 @@ var import_core3 = require("@pandacss/core");
 // src/analyze-tokens.ts
 init_cjs_shims();
 var import_logger = require("@pandacss/logger");
+var import_filesize = require("filesize");
 var import_promises = require("fs/promises");
-var import_ts_morph = require("ts-morph");
+var import_zlib = __toESM(require("zlib"));
 
 // src/classify.ts
 init_cjs_shims();
@@ -551,7 +482,7 @@ var classifyTokens = (ctx, parserResultByFilepath) => {
     }
     if (type === "pattern") {
       const pattern = ctx.patterns.getConfig(from.toLowerCase());
-      const patternProp = pattern.properties[propName];
+      const patternProp = pattern?.properties?.[propName];
       if (!patternProp)
         return false;
       if (patternProp.type === "boolean" || patternProp.type === "number") {
@@ -763,58 +694,25 @@ 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 }));
 };
 
-// src/get-node-range.ts
-init_cjs_shims();
-var getNodeRange = (node) => {
-  const src = node.getSourceFile();
-  const [startPosition, endPosition] = [node.getStart(), node.getEnd()];
-  const startInfo = src.getLineAndColumnAtPos(startPosition);
-  const endInfo = src.getLineAndColumnAtPos(endPosition);
-  return {
-    startPosition,
-    startLineNumber: startInfo.line,
-    startColumn: startInfo.column,
-    endPosition,
-    endLineNumber: endInfo.line,
-    endColumn: endInfo.column
-  };
-};
-
-// src/analyze-tokens.ts
-var import_filesize = require("filesize");
-
-// ../../node_modules/.pnpm/gzip-size@7.0.0/node_modules/gzip-size/index.js
-init_cjs_shims();
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_stream = __toESM(require("stream"), 1);
-var import_node_zlib = __toESM(require("zlib"), 1);
-var import_node_util = require("util");
-var import_duplexer = __toESM(require_duplexer(), 1);
-var getOptions = (options) => ({ level: 9, ...options });
-var gzip = (0, import_node_util.promisify)(import_node_zlib.default.gzip);
-function gzipSizeSync(input, options) {
-  return import_node_zlib.default.gzipSync(input, getOptions(options)).length;
-}
-
 // src/analyze-tokens.ts
+var gzipSizeSync = (code) => import_zlib.default.gzipSync(code, { level: import_zlib.default.constants.Z_BEST_COMPRESSION }).length;
 function analyzeTokens(ctx, options = {}) {
-  const parserResultByFilepath = /* @__PURE__ */ new Map();
-  const extractTimeByFilepath = /* @__PURE__ */ new Map();
-  const includedFiles = ctx.getFiles();
-  includedFiles.map((file) => {
+  const filesMap = /* @__PURE__ */ new Map();
+  const timesMap = /* @__PURE__ */ new Map();
+  const files = ctx.getFiles();
+  files.forEach((file) => {
     const start2 = performance.now();
     const result = ctx.project.parseSourceFile(file);
     const extractMs = performance.now() - start2;
-    extractTimeByFilepath.set(file, extractMs);
+    timesMap.set(file, extractMs);
     import_logger.logger.debug("analyze", `Parsed ${file} in ${extractMs}ms`);
     if (result) {
-      parserResultByFilepath.set(file, result);
+      filesMap.set(file, result);
       options.onResult?.(file, result);
     }
-    return [file, result];
   });
-  const totalMs = Array.from(extractTimeByFilepath.values()).reduce((a, b) => a + b, 0);
-  import_logger.logger.debug("analyze", `Analyzed ${includedFiles.length} files in ${totalMs.toFixed(2)}ms`);
+  const totalMs = Array.from(timesMap.values()).reduce((a, b) => a + b, 0);
+  import_logger.logger.debug("analyze", `Analyzed ${files.length} files in ${totalMs.toFixed(2)}ms`);
   const minify = ctx.config.minify;
   const chunkFiles = ctx.chunks.getFiles();
   ctx.config.optimize = true;
@@ -824,18 +722,17 @@ function analyzeTokens(ctx, options = {}) {
   const minifiedCss = ctx.getCss({ files: chunkFiles });
   ctx.config.minify = minify;
   const start = performance.now();
-  const analysis = classifyTokens(ctx, parserResultByFilepath);
+  const analysis = classifyTokens(ctx, filesMap);
   const classifyMs = performance.now() - start;
   return Object.assign(
     {
       duration: {
-        extractTimeByFiles: Object.fromEntries(extractTimeByFilepath.entries()),
+        extractTimeByFiles: Object.fromEntries(timesMap.entries()),
         extractTotal: totalMs,
         classify: classifyMs
       },
       fileSizes: {
         lineCount: css.split("\n").length,
-        // rulesCount: css.split('{').length - 1, ?
         normal: (0, import_filesize.filesize)(Buffer.byteLength(css, "utf-8")),
         minified: (0, import_filesize.filesize)(Buffer.byteLength(minifiedCss, "utf-8")),
         gzip: {
@@ -854,14 +751,11 @@ var analyzeResultSerializer = (_key, value) => {
   if (value instanceof Map) {
     return Object.fromEntries(value);
   }
-  if (import_ts_morph.Node.isNode(value)) {
-    return { kind: value.getKindName(), range: getNodeRange(value) };
-  }
   return value;
 };
 var writeAnalyzeJSON = (fileName, result, ctx) => {
   result.details.byInstanceId.forEach((item) => {
-    item.box = { type: item.box.type, node: item.box.getNode(), stack: item.box.getStack() };
+    item.box = item.box.toJSON();
   });
   return (0, import_promises.writeFile)(
     fileName,
@@ -882,16 +776,18 @@ var writeAnalyzeJSON = (fileName, result, ctx) => {
 
 // src/builder.ts
 init_cjs_shims();
+var import_config2 = require("@pandacss/config");
 var import_core2 = require("@pandacss/core");
 var import_error = require("@pandacss/error");
 var import_logger4 = require("@pandacss/logger");
-var import_fs2 = require("fs");
+var import_fs = require("fs");
 var import_fs_extra2 = require("fs-extra");
-var import_path4 = require("path");
+var import_path3 = require("path");
 
 // src/config.ts
 init_cjs_shims();
 var import_config = require("@pandacss/config");
+var import_hookable = require("hookable");
 var import_look_it_up = require("look-it-up");
 
 // src/create-context.ts
@@ -903,18 +799,22 @@ var import_lil_fp = require("lil-fp");
 // src/chunk-engine.ts
 init_cjs_shims();
 var import_core = require("@pandacss/core");
-var getChunkEngine = ({ paths, config, runtime: { path: path3, fs: fs3 } }) => ({
-  dir: path3.join(...paths.chunk),
+var getChunkEngine = ({
+  paths,
+  config,
+  runtime: { path: path2, fs }
+}) => ({
+  dir: path2.join(...paths.chunk),
   readFile(file) {
-    const fileName = path3.join(...paths.chunk, this.format(file));
-    return fs3.existsSync(fileName) ? fs3.readFileSync(fileName) : "";
+    const fileName = path2.join(...paths.chunk, this.format(file));
+    return fs.existsSync(fileName) ? fs.readFileSync(fileName) : "";
   },
   getFiles() {
-    const files = fs3.existsSync(this.dir) ? fs3.readDirSync(this.dir) : [];
-    return files.map((file) => fs3.readFileSync(path3.join(this.dir, file)));
+    const files = fs.existsSync(this.dir) ? fs.readDirSync(this.dir) : [];
+    return files.map((file) => fs.readFileSync(path2.join(this.dir, file)));
   },
   format(file) {
-    return path3.relative(config.cwd, file).replaceAll(path3.sep, "__").replace(path3.extname(file), ".css");
+    return path2.relative(config.cwd, file).replaceAll(path2.sep, "__").replace(path2.extname(file), ".css");
   },
   getArtifact(file, css) {
     const fileName = this.format(file);
@@ -925,10 +825,10 @@ var getChunkEngine = ({ paths, config, runtime: { path: path3, fs: fs3 } }) => (
     };
   },
   rm(file) {
-    return fs3.rmFileSync(path3.join(...paths.chunk, this.format(file)));
+    return fs.rmFileSync(path2.join(...paths.chunk, this.format(file)));
   },
   empty() {
-    return fs3.rmDirSync(this.dir);
+    return fs.rmDirSync(this.dir);
   },
   get glob() {
     return [`${this.dir}/**/*.css`];
@@ -968,15 +868,19 @@ var nodeRuntime = {
     glob(opts) {
       if (!opts.include)
         return [];
-      return import_fast_glob.default.sync(opts.include, { cwd: opts.cwd, ignore: opts.exclude, absolute: true });
+      const ignore = opts.exclude ?? [];
+      if (!ignore.length) {
+        ignore.push("**/*.d.ts");
+      }
+      return import_fast_glob.default.sync(opts.include, { cwd: opts.cwd, ignore, absolute: true });
     },
     writeFile: import_fs_extra.writeFile,
     writeFileSync: import_fs_extra.writeFileSync,
     readDirSync: import_fs_extra.readdirSync,
     rmDirSync: import_fs_extra.emptyDirSync,
     rmFileSync: import_fs_extra.removeSync,
-    ensureDirSync(path3) {
-      return (0, import_fs_extra.ensureDirSync)(path3);
+    ensureDirSync(path2) {
+      return (0, import_fs_extra.ensureDirSync)(path2);
     },
     watch(options) {
       const { include, exclude, cwd, poll } = options;
@@ -1007,20 +911,23 @@ process.on("uncaughtException", (reason) => {
 
 // src/output-engine.ts
 init_cjs_shims();
-var getOutputEngine = ({ paths, runtime: { path: path3, fs: fs3 } }) => ({
+var getOutputEngine = ({
+  paths,
+  runtime: { path: path2, fs }
+}) => ({
   empty() {
-    fs3.rmDirSync(path3.join(...paths.root));
+    fs.rmDirSync(path2.join(...paths.root));
   },
   async write(output) {
     if (!output)
       return;
     const { dir = paths.root, files } = output;
-    fs3.ensureDirSync(path3.join(...dir));
+    fs.ensureDirSync(path2.join(...dir));
     return Promise.all(
       files.map(async ({ file, code }) => {
-        const absPath = path3.join(...dir, file);
+        const absPath = path2.join(...dir, file);
         if (code) {
-          return fs3.writeFile(absPath, code);
+          return fs.writeFile(absPath, code);
         }
       })
     );
@@ -1031,18 +938,19 @@ var getOutputEngine = ({ paths, runtime: { path: path3, fs: fs3 } }) => ({
 var createContext = (conf) => (0, import_lil_fp.pipe)(
   conf,
   import_generator.createGenerator,
-  import_lil_fp.Obj.assign({ runtime: nodeRuntime }),
+  import_lil_fp.Obj.assign({ runtime: nodeRuntime, hooks: conf.hooks }),
   (0, import_lil_fp.tap)(({ config, runtime }) => {
     config.cwd ||= runtime.cwd();
   }),
-  import_lil_fp.Obj.bind("getFiles", ({ config, runtime: { fs: fs3 } }) => () => {
+  import_lil_fp.Obj.bind("getFiles", ({ config, runtime: { fs } }) => () => {
     const { include, exclude, cwd } = config;
-    return fs3.glob({ include, exclude, cwd });
+    return fs.glob({ include, exclude, cwd });
   }),
-  import_lil_fp.Obj.bind("project", ({ getFiles, runtime: { fs: fs3 }, parserOptions }) => {
+  import_lil_fp.Obj.bind("project", ({ getFiles, runtime: { fs }, parserOptions }) => {
     return (0, import_parser.createProject)({
       getFiles,
-      readFile: fs3.readFileSync,
+      readFile: fs.readFileSync,
+      hooks: conf.hooks,
       parserOptions
     });
   }),
@@ -1061,6 +969,7 @@ function findConfig() {
   }
 }
 async function loadConfigAndCreateContext(options = {}) {
+  const hooks = (0, import_hookable.createHooks)();
   const { cwd = process.cwd(), config, configPath } = options;
   const conf = await (0, import_config.loadConfigFile)({ cwd, file: configPath });
   if (config) {
@@ -1069,7 +978,15 @@ async function loadConfigAndCreateContext(options = {}) {
   if (options.cwd) {
     conf.config.cwd = options.cwd;
   }
-  return createContext(conf);
+  conf.config.outdir ??= "styled-system";
+  if (conf.config.hooks) {
+    hooks.addHooks(conf.config.hooks);
+  }
+  await hooks.callHook("config:resolved", conf);
+  if (conf.config.logLevel === "debug") {
+    (0, import_hookable.createDebugger)(hooks, { tag: "panda" });
+  }
+  return createContext({ ...conf, hooks });
 }
 
 // src/extract.ts
@@ -1087,7 +1004,7 @@ var import_node_process2 = __toESM(require("process"), 1);
 // ../../node_modules/.pnpm/string-width@5.1.2/node_modules/string-width/index.js
 init_cjs_shims();
 
-// ../../node_modules/.pnpm/strip-ansi@7.0.1/node_modules/strip-ansi/index.js
+// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
 init_cjs_shims();
 
 // ../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js
@@ -1100,12 +1017,13 @@ function ansiRegex({ onlyFirst = false } = {}) {
   return new RegExp(pattern, onlyFirst ? void 0 : "g");
 }
 
-// ../../node_modules/.pnpm/strip-ansi@7.0.1/node_modules/strip-ansi/index.js
+// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
 function stripAnsi(string) {
   if (typeof string !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
   }
-  return string.replace(ansiRegex(), "");
+  return string.replace(regex, "");
 }
 
 // ../../node_modules/.pnpm/string-width@5.1.2/node_modules/string-width/index.js
@@ -1454,9 +1372,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   }
   return min;
 }
-function createSupportsColor(stream2, options = {}) {
-  const level = _supportsColor(stream2, {
-    streamIsTTY: stream2 && stream2.isTTY,
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
     ...options
   });
   return translateLevel(level);
@@ -1747,70 +1665,78 @@ var import_ansi_align = __toESM(require_ansi_align(), 1);
 // ../../node_modules/.pnpm/wrap-ansi@8.1.0/node_modules/wrap-ansi/index.js
 init_cjs_shims();
 
-// ../../node_modules/.pnpm/ansi-styles@6.1.1/node_modules/ansi-styles/index.js
+// ../../node_modules/.pnpm/ansi-styles@6.2.1/node_modules/ansi-styles/index.js
 init_cjs_shims();
 var ANSI_BACKGROUND_OFFSET2 = 10;
 var wrapAnsi162 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi2562 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
 var wrapAnsi16m2 = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles3 = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames2 = Object.keys(styles3.modifier);
+var foregroundColorNames2 = Object.keys(styles3.color);
+var backgroundColorNames2 = Object.keys(styles3.bgColor);
+var colorNames2 = [...foregroundColorNames2, ...backgroundColorNames2];
 function assembleStyles2() {
   const codes = /* @__PURE__ */ new Map();
-  const styles3 = {
-    modifier: {
-      reset: [0, 0],
-      // 21 isn't widely supported and 22 does the same thing
-      bold: [1, 22],
-      dim: [2, 22],
-      italic: [3, 23],
-      underline: [4, 24],
-      overline: [53, 55],
-      inverse: [7, 27],
-      hidden: [8, 28],
-      strikethrough: [9, 29]
-    },
-    color: {
-      black: [30, 39],
-      red: [31, 39],
-      green: [32, 39],
-      yellow: [33, 39],
-      blue: [34, 39],
-      magenta: [35, 39],
-      cyan: [36, 39],
-      white: [37, 39],
-      // Bright color
-      blackBright: [90, 39],
-      redBright: [91, 39],
-      greenBright: [92, 39],
-      yellowBright: [93, 39],
-      blueBright: [94, 39],
-      magentaBright: [95, 39],
-      cyanBright: [96, 39],
-      whiteBright: [97, 39]
-    },
-    bgColor: {
-      bgBlack: [40, 49],
-      bgRed: [41, 49],
-      bgGreen: [42, 49],
-      bgYellow: [43, 49],
-      bgBlue: [44, 49],
-      bgMagenta: [45, 49],
-      bgCyan: [46, 49],
-      bgWhite: [47, 49],
-      // Bright color
-      bgBlackBright: [100, 49],
-      bgRedBright: [101, 49],
-      bgGreenBright: [102, 49],
-      bgYellowBright: [103, 49],
-      bgBlueBright: [104, 49],
-      bgMagentaBright: [105, 49],
-      bgCyanBright: [106, 49],
-      bgWhiteBright: [107, 49]
-    }
-  };
-  styles3.color.gray = styles3.color.blackBright;
-  styles3.bgColor.bgGray = styles3.bgColor.bgBlackBright;
-  styles3.color.grey = styles3.color.blackBright;
-  styles3.bgColor.bgGrey = styles3.bgColor.bgBlackBright;
   for (const [groupName, group] of Object.entries(styles3)) {
     for (const [styleName, style] of Object.entries(group)) {
       styles3[styleName] = {
@@ -2375,8 +2301,8 @@ async function bundleChunks(ctx) {
   });
 }
 async function writeFileChunk(ctx, file) {
-  const { path: path3 } = ctx.runtime;
-  import_logger3.logger.debug("chunk:write", `File: ${path3.relative(ctx.config.cwd, file)}`);
+  const { path: path2 } = ctx.runtime;
+  import_logger3.logger.debug("chunk:write", `File: ${path2.relative(ctx.config.cwd, file)}`);
   const css = extractFile(ctx, file);
   if (!css)
     return;
@@ -2385,11 +2311,11 @@ async function writeFileChunk(ctx, file) {
 }
 function extractFile(ctx, file) {
   const {
-    runtime: { path: path3 },
+    runtime: { path: path2 },
     config: { cwd }
   } = ctx;
   return (0, import_lil_fp2.pipe)(
-    { file: path3.abs(cwd, file) },
+    { file: path2.abs(cwd, file) },
     (0, import_lil_fp2.tap)(() => import_logger3.logger.debug("file:extract", file)),
     import_lil_fp2.Obj.bind("measure", () => import_logger3.logger.time.debug(`Extracted ${file}`)),
     import_lil_fp2.Obj.bind(
@@ -2431,62 +2357,10 @@ async function extractCss(ctx) {
   return ctx.messages.buildComplete(ctx.getFiles().length);
 }
 
-// src/get-mod-deps.ts
-init_cjs_shims();
-var import_fs = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
-var jsExtensions = [".js", ".cjs", ".mjs"];
-var jsResolutionOrder = ["", ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts", ".jsx", ".tsx"];
-var tsResolutionOrder = ["", ".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"];
-function resolveWithExtension(file, extensions) {
-  for (const ext of extensions) {
-    const full = `${file}${ext}`;
-    if (import_fs.default.existsSync(full) && import_fs.default.statSync(full).isFile()) {
-      return full;
-    }
-  }
-  for (const ext of extensions) {
-    const full = `${file}/index${ext}`;
-    if (import_fs.default.existsSync(full)) {
-      return full;
-    }
-  }
-  return null;
-}
-function* getDeps(filename, base, seen, ext = import_path2.default.extname(filename)) {
-  const absoluteFile = resolveWithExtension(
-    import_path2.default.resolve(base, filename),
-    jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder
-  );
-  if (absoluteFile === null)
-    return;
-  if (seen.has(absoluteFile))
-    return;
-  seen.add(absoluteFile);
-  yield absoluteFile;
-  base = import_path2.default.dirname(absoluteFile);
-  ext = import_path2.default.extname(absoluteFile);
-  const contents = import_fs.default.readFileSync(absoluteFile, "utf-8");
-  for (const match2 of [
-    ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
-    ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
-    ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi)
-  ]) {
-    if (!match2[1].startsWith("."))
-      continue;
-    yield* getDeps(match2[1], base, seen, ext);
-  }
-}
-function getModuleDependencies(filePath) {
-  if (filePath === null)
-    return /* @__PURE__ */ new Set();
-  return new Set(getDeps(filePath, import_path2.default.dirname(filePath), /* @__PURE__ */ new Set()));
-}
-
 // src/parse-dependency.ts
 init_cjs_shims();
 var import_is_glob = __toESM(require("is-glob"));
-var import_path3 = require("path");
+var import_path2 = require("path");
 
 // src/parse-glob.ts
 init_cjs_shims();
@@ -2517,9 +2391,9 @@ function parseDependency(fileOrGlob) {
   let message = null;
   if ((0, import_is_glob.default)(fileOrGlob)) {
     const { base, glob: glob2 } = parseGlob(fileOrGlob);
-    message = { type: "dir-dependency", dir: (0, import_path3.resolve)(base), glob: glob2 };
+    message = { type: "dir-dependency", dir: (0, import_path2.resolve)(base), glob: glob2 };
   } else {
-    message = { type: "dependency", file: (0, import_path3.resolve)(fileOrGlob) };
+    message = { type: "dependency", file: (0, import_path2.resolve)(fileOrGlob) };
   }
   if (message.type === "dir-dependency" && process.env.ROLLUP_WATCH === "true") {
     message = { type: "dependency", file: message.dir };
@@ -2559,7 +2433,7 @@ var Builder = class {
       delete require.cache[file];
     }
     if (setupCount > 0) {
-      import_logger4.logger.info("postcss", "\u2699\uFE0F Config changed, reloading");
+      import_logger4.logger.debug("builder", "\u2699\uFE0F Config changed, reloading");
     }
     return { isModified: true, modifiedMap: newModified };
   }
@@ -2570,15 +2444,18 @@ var Builder = class {
     }
     return configPath;
   }
-  async setup() {
-    const configPath = this.getConfigPath();
-    const configDeps = getModuleDependencies(configPath);
+  async setup(options = {}) {
+    import_logger4.logger.debug("builder", "\u{1F6A7} Setup");
+    const configPath = options.configPath ?? this.getConfigPath();
+    const { deps: configDeps } = (0, import_config2.getConfigDependencies)(configPath);
     const deps = this.checkConfigDeps(configPath, configDeps);
     if (deps.isModified) {
-      return this.setupContext({
+      await this.setupContext({
         configPath,
         depsModifiedMap: deps.modifiedMap
       });
+      const updatedCtx = this.context;
+      await updatedCtx.hooks.callHook("config:change", updatedCtx.config);
     }
     const cache = configCache.get(configPath);
     if (cache) {
@@ -2600,7 +2477,7 @@ var Builder = class {
     }
     configCache.set(configPath, {
       context: this.context,
-      deps: new Set(this.context.configDependencies),
+      deps: new Set(this.context.dependencies ?? []),
       depsModifiedMap
     });
     contentFilesCache.set(this.context, {
@@ -2623,7 +2500,7 @@ var Builder = class {
     return contentFilesCache.get(ctx).fileCssMap;
   }
   async extractFile(ctx, file) {
-    const mtime = (0, import_fs2.existsSync)(file) ? (0, import_fs_extra2.statSync)(file).mtimeMs : -Infinity;
+    const mtime = (0, import_fs.existsSync)(file) ? (0, import_fs_extra2.statSync)(file).mtimeMs : -Infinity;
     const isUnchanged = this.fileModifiedMap.has(file) && mtime === this.fileModifiedMap.get(file);
     if (isUnchanged)
       return;
@@ -2677,7 +2554,7 @@ var Builder = class {
       }
     }
     for (const file of ctx.dependencies) {
-      fn({ type: "dependency", file: (0, import_path4.resolve)(file) });
+      fn({ type: "dependency", file: (0, import_path3.resolve)(file) });
     }
   }
 };
@@ -2685,17 +2562,18 @@ var Builder = class {
 // src/debug-files.ts
 init_cjs_shims();
 var import_logger5 = require("@pandacss/logger");
-var import_promises2 = require("fs/promises");
-var path2 = __toESM(require("path"));
+var nodePath = __toESM(require("path"));
 async function debugFiles(ctx, options) {
   const files = ctx.getFiles();
   const measureTotal = import_logger5.logger.time.debug(`Done parsing ${files.length} files`);
   ctx.config.minify = false;
   ctx.config.optimize = true;
-  if (!options.dry && options.outdir) {
-    await (0, import_promises2.mkdir)(options.outdir, { recursive: true });
-    import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${options.outdir}/config.json`)}`);
-    await (0, import_promises2.writeFile)(`${options.outdir}/config.json`, JSON.stringify(ctx.config, null, 2));
+  const { fs, path: path2 } = ctx.runtime;
+  const outdir = options.outdir;
+  if (!options.dry && outdir) {
+    fs.ensureDirSync(outdir);
+    import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${outdir}/config.json`)}`);
+    await fs.writeFile(`${outdir}/config.json`, JSON.stringify(ctx.config, null, 2));
   }
   const filesWithCss = [];
   await Promise.all(
@@ -2705,18 +2583,7 @@ async function debugFiles(ctx, options) {
       measure();
       if (!result)
         return;
-      const list = result.getAll().map((result2) => {
-        const node = result2.box.getNode();
-        const range = getNodeRange(node);
-        return {
-          name: result2.name,
-          type: result2.type,
-          data: result2.data,
-          kind: node.getKindName(),
-          line: range.startLineNumber,
-          column: range.startColumn
-        };
-      });
+      const list = result.toArray().map((resultItem) => resultItem.box?.toJSON?.() ?? resultItem);
       const css = ctx.getParserCss(result);
       if (!css)
         return;
@@ -2724,17 +2591,17 @@ async function debugFiles(ctx, options) {
         console.log({ path: file, ast: list, code: css });
         return Promise.resolve();
       }
-      if (options.outdir) {
+      if (outdir) {
         filesWithCss.push(file);
-        const parsedPath = path2.parse(file);
+        const parsedPath = nodePath.parse(file);
         const relative3 = path2.relative(ctx.config.cwd, parsedPath.dir);
         const astJsonPath = `${relative3}/${parsedPath.name}.ast.json`.replaceAll(path2.sep, "__");
         const cssPath = `${relative3}/${parsedPath.name}.css`.replaceAll(path2.sep, "__");
-        import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${options.outdir}/${astJsonPath}`)}`);
-        import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${options.outdir}/${cssPath}`)}`);
+        import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${outdir}/${astJsonPath}`)}`);
+        import_logger5.logger.info("cli", `Writing ${import_logger5.colors.bold(`${outdir}/${cssPath}`)}`);
         return Promise.all([
-          (0, import_promises2.writeFile)(`${options.outdir}/${astJsonPath}`, JSON.stringify(list, debugResultSerializer, 2)),
-          (0, import_promises2.writeFile)(`${options.outdir}/${cssPath}`, css)
+          fs.writeFile(`${outdir}/${astJsonPath}`, JSON.stringify(list, debugResultSerializer, 2)),
+          fs.writeFile(`${outdir}/${cssPath}`, css)
         ]);
       }
     })
@@ -2797,22 +2664,23 @@ async function generate(config, configPath) {
   const ctx = ctxRef.current;
   await build(ctx);
   const {
-    runtime: { fs: fs3, path: path3 },
+    runtime: { fs, path: path2 },
     dependencies,
     config: { cwd }
   } = ctx;
   if (ctx.config.watch) {
-    const configWatcher = fs3.watch({ include: dependencies });
+    const configWatcher = fs.watch({ include: dependencies });
     configWatcher.on("change", async () => {
       import_logger7.logger.info("config:change", "Config changed, restarting...");
       await loadCtx();
+      await ctxRef.current.hooks.callHook("config:change", ctxRef.current.config);
       return build(ctxRef.current);
     });
-    const contentWatcher = fs3.watch(ctx.config);
+    const contentWatcher = fs.watch(ctx.config);
     contentWatcher.on("all", async (event, file) => {
       import_logger7.logger.info(`file:${event}`, file);
       (0, import_ts_pattern.match)(event).with("unlink", () => {
-        ctx.project.removeSourceFile(path3.abs(cwd, file));
+        ctx.project.removeSourceFile(path2.abs(cwd, file));
         ctx.chunks.rm(file);
       }).with("change", async () => {
         ctx.project.reloadSourceFile(file);
@@ -2830,23 +2698,26 @@ async function generate(config, configPath) {
 
 // src/git-ignore.ts
 init_cjs_shims();
-var import_fs3 = require("fs");
+var import_fs2 = require("fs");
 var import_look_it_up2 = require("look-it-up");
 var import_outdent = __toESM(require("outdent"));
-function setupGitIgnore({ config: { outdir, gitignore = true } }) {
+function setupGitIgnore(ctx) {
+  const { outdir, gitignore } = ctx.config;
   if (!gitignore)
     return;
-  const txt = import_outdent.default`## Panda
+  const txt = import_outdent.default`
+  
+  ## Panda
   ${outdir}
-  ${outdir}-static
+  ${ctx.studio.outdir}
   `;
   const file = (0, import_look_it_up2.lookItUpSync)(".gitignore");
   if (!file) {
-    return (0, import_fs3.writeFileSync)(".gitignore", txt);
+    return (0, import_fs2.writeFileSync)(".gitignore", txt);
   }
-  const content = (0, import_fs3.readFileSync)(file, "utf-8");
+  const content = (0, import_fs2.readFileSync)(file, "utf-8");
   if (!content.includes(outdir)) {
-    (0, import_fs3.appendFileSync)(file, txt);
+    (0, import_fs2.appendFileSync)(file, txt);
   }
 }
 
@@ -2857,9 +2728,10 @@ var import_generator2 = require("@pandacss/generator");
 var import_fs_extra3 = require("fs-extra");
 var import_look_it_up3 = require("look-it-up");
 var import_outdent2 = require("outdent");
-var import_path5 = require("path");
+var import_path4 = require("path");
 var import_preferred_pm2 = __toESM(require("preferred-pm"));
-async function setupConfig(cwd, { force }) {
+async function setupConfig(cwd, opts = {}) {
+  const { force, outExtension, jsxFramework } = opts;
   const configFile = findConfig();
   const pmResult = await (0, import_preferred_pm2.default)(cwd);
   const pm = pmResult?.name ?? "npm";
@@ -2871,36 +2743,74 @@ async function setupConfig(cwd, { force }) {
     import_logger8.logger.warn("init:config", import_generator2.messages.configExists(cmd));
   } else {
     const content = import_outdent2.outdent`
-       import { defineConfig } from "@pandacss/dev"
+import { defineConfig } from "@pandacss/dev"
+
+export default defineConfig({
+    // Whether to use css reset
+    preflight: true,
+    ${outExtension ? `
+ // The extension for the emitted JavaScript files
+outExtension: '${outExtension}',` : ""}
+    // Where to look for your css declarations
+    include: ["./src/**/*.{js,jsx,ts,tsx}", "./pages/**/*.{js,jsx,ts,tsx}"],
+
+    // Files to exclude
+    exclude: [],
 
-       export default defineConfig({
-        // Whether to use css reset
-        preflight: true,
-        
-        // Where to look for your css declarations
-        include: ["./src/**/*.{js,jsx,ts,tsx}", "./pages/**/*.{js,jsx,ts,tsx}"],
-        
-        // Files to exclude
-        exclude: [],
-        
-        // The output directory for your css system
-        outdir: "styled-system",
-       })
+    // Useful for theme customization
+    theme: {
+      extend: {}
+    },
+
+    // The output directory for your css system
+    outdir: "styled-system",
+    ${jsxFramework ? `
+ // The JSX framework to use
+jsxFramework: '${jsxFramework}'` : ""}
+})
     `;
-    await (0, import_fs_extra3.writeFile)((0, import_path5.join)(cwd, file), content);
+    await (0, import_fs_extra3.writeFile)((0, import_path4.join)(cwd, file), content);
     import_logger8.logger.log(import_generator2.messages.thankYou());
   }
 }
 async function setupPostcss(cwd) {
   import_logger8.logger.info("init:postcss", `creating postcss config file: ${(0, import_logger8.quote)("postcss.config.cjs")}`);
   const content = import_outdent2.outdent`
-  module.exports = {
-    plugins: {
-      '@pandacss/dev/postcss': {},
-    },
-  }
+module.exports = {
+  plugins: {
+    '@pandacss/dev/postcss': {},
+  },
+}
   `;
-  await (0, import_fs_extra3.writeFile)((0, import_path5.join)(cwd, "postcss.config.cjs"), content);
+  await (0, import_fs_extra3.writeFile)((0, import_path4.join)(cwd, "postcss.config.cjs"), content);
+}
+
+// src/ship-files.ts
+init_cjs_shims();
+var import_logger9 = require("@pandacss/logger");
+var import_parser2 = require("@pandacss/parser");
+var import_promises2 = require("fs/promises");
+var path = __toESM(require("path"));
+async function shipFiles(ctx, outfile) {
+  const files = ctx.getFiles();
+  const extractResult = (0, import_parser2.createParserResult)();
+  const filesWithCss = [];
+  files.forEach(async (file) => {
+    const result = ctx.project.parseSourceFile(file);
+    if (!result || result.isEmpty())
+      return;
+    const css = ctx.getParserCss(result);
+    if (!css)
+      return;
+    extractResult.merge(result);
+    filesWithCss.push(path.relative(ctx.config.cwd, file));
+  });
+  import_logger9.logger.info("cli", `Found ${import_logger9.colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
+  const minify = ctx.config.minify;
+  import_logger9.logger.info("cli", `Writing ${minify ? "[min] " : " "}${import_logger9.colors.bold(outfile)}`);
+  const output = JSON.stringify(extractResult.toJSON(), null, minify ? 0 : 2);
+  await (0, import_promises2.writeFile)(outfile, output);
+  import_logger9.logger.info("cli", "Done!");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2913,10 +2823,14 @@ async function setupPostcss(cwd) {
   emitArtifacts,
   execCommand,
   extractCss,
+  extractFile,
+  findConfig,
   generate,
   loadConfigAndCreateContext,
+  parseDependency,
   setupConfig,
   setupGitIgnore,
   setupPostcss,
+  shipFiles,
   writeAnalyzeJSON
 });