@pandacss/config 1.11.2 → 2.0.0-beta.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Segun Adebayo
+Copyright (c) 2023 Chakra Systems Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,12 @@
+# @pandacss/config
+
+Loads, bundles, and serializes a Panda CSS config into the self-contained snapshot consumed by the Rust compiler.
+Internal package used by `@pandacss/cli` / `@pandacss/dev`; you typically don't install it directly.
+
+## Documentation
+
+Visit the [Panda CSS documentation](https://panda-css.com) to learn more.
+
+## License
+
+MIT © [Chakra Systems Inc.](https://github.com/chakra-ui)

package/dist/chunk-LUSBBUHX.js

@@ -0,0 +1,250 @@
+// src/error.ts
+var PandaError = class extends Error {
+  code;
+  hint;
+  constructor(code, message, opts) {
+    super(message, { cause: opts?.cause });
+    this.code = `ERR_PANDA_${code}`;
+    this.hint = opts?.hint;
+  }
+};
+
+// src/sources.ts
+var sectionKeySet = /* @__PURE__ */ new Set([
+  "conditions",
+  "theme",
+  "patterns",
+  "utilities",
+  "globalCss",
+  "globalVars",
+  "globalFontface",
+  "globalPositionTry",
+  "staticCss",
+  "themes"
+]);
+var omitKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var tokenKeys = /* @__PURE__ */ new Set(["description", "extensions", "type", "value", "deprecated"]);
+var directFieldSections = /* @__PURE__ */ new Set(["patterns", "utilities"]);
+var themeEntryKeys = /* @__PURE__ */ new Set([
+  "animationStyles",
+  "breakpoints",
+  "containers",
+  "keyframes",
+  "layerStyles",
+  "recipes",
+  "slotRecipes",
+  "textStyles"
+]);
+var SourceTracker = class {
+  sources;
+  constructor(entries) {
+    this.sources = { entries, paths: {} };
+  }
+  record(path, sourceId, mode) {
+    const key = path.join(".");
+    const current = this.sources.paths[key];
+    if (current === void 0 || mode === "replace") {
+      this.sources.paths[key] = sourceId;
+      return;
+    }
+    if (Array.isArray(current)) {
+      if (!current.includes(sourceId)) current.push(sourceId);
+      return;
+    }
+    if (current !== sourceId) this.sources.paths[key] = [current, sourceId];
+  }
+  moveIfMissing(from, to) {
+    const fromKey = from.join(".");
+    const toKey = to.join(".");
+    if (this.sources.paths[fromKey] === void 0) return;
+    this.sources.paths[toKey] ??= this.sources.paths[fromKey];
+    delete this.sources.paths[fromKey];
+  }
+  delete(path) {
+    delete this.sources.paths[path.join(".")];
+  }
+};
+function recordSource(context, path, value, current, mode) {
+  if (!context || !path || !shouldTrackPath(path, value, current)) return;
+  context.tracker.record(path, context.sourceId, mode);
+}
+function recordNestedSources(context, path, value) {
+  if (!context || !path || !isPlainObject(value)) return;
+  for (const [key, child] of Object.entries(value)) {
+    if (child === void 0 || omitKeys.has(key)) continue;
+    const childPath = path.concat(key);
+    recordSource(context, childPath, child, void 0, "replace");
+    recordNestedSources(context, childPath, child);
+  }
+}
+function shouldTrackPath(path, value, current) {
+  if (path.length === 1) return true;
+  const [section, ...rest] = path;
+  if (!sectionKeySet.has(section) || rest.length === 0) return false;
+  if (section === "theme") return shouldTrackThemePath(rest, value, current);
+  if (section === "staticCss") return shouldTrackStaticCssPath(rest);
+  if (section === "conditions" || section === "globalVars") return rest.length === 1;
+  if (directFieldSections.has(section)) return rest.length <= 2;
+  return rest.length === 1;
+}
+function shouldTrackStaticCssPath(rest) {
+  return rest.length === 1 || (rest[0] === "recipes" || rest[0] === "patterns") && rest.length === 2;
+}
+function shouldTrackThemePath(rest, value, current) {
+  const [key] = rest;
+  if (key === "tokens" || key === "semanticTokens") {
+    if (rest.length < 3) return false;
+    const last = rest.at(-1);
+    return tokenKeys.has(last) || isPlainObject(value) || current !== void 0;
+  }
+  if (themeEntryKeys.has(key)) return rest.length <= 3;
+  if (key === "containerNames" || key === "colorPalette") return rest.length <= 2;
+  return rest.length <= 2;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/shared.ts
+var omitKeys2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function clone(value) {
+  if (Array.isArray(value)) return value.map((item) => clone(item));
+  if (isPlainObject2(value)) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== void 0 && !omitKeys2.has(key)) result[key] = clone(item);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/merge.ts
+var sectionKeys = [
+  "conditions",
+  "theme",
+  "patterns",
+  "utilities",
+  "globalCss",
+  "globalVars",
+  "globalFontface",
+  "globalPositionTry",
+  "staticCss",
+  "themes"
+];
+var sectionKeySet2 = new Set(sectionKeys);
+var runtimeOnlyKeys = /* @__PURE__ */ new Set(["presets", "plugins", "hooks", "name", "extend"]);
+var tokenKeys2 = /* @__PURE__ */ new Set(["description", "extensions", "type", "value", "deprecated"]);
+function mergeConfigsWithSources(configs) {
+  const tracker = new SourceTracker(configs.map((item) => item.source));
+  const config = mergeConfigs(configs, tracker);
+  return { config, sources: tracker.sources };
+}
+function mergeConfigs(configs, tracker) {
+  const result = {};
+  const sections = Object.fromEntries(sectionKeys.map((key) => [key, {}]));
+  for (let index = 0; index < configs.length; index++) {
+    const config = tracker ? configs[index].config : configs[index];
+    const context = tracker ? { tracker, sourceId: index, path: [] } : void 0;
+    for (const [key, value] of Object.entries(config)) {
+      if (value === void 0 || sectionKeySet2.has(key) || runtimeOnlyKeys.has(key) || omitKeys2.has(key)) continue;
+      result[key] = clone(value);
+      context?.tracker.record([key], context.sourceId, "replace");
+    }
+    for (const key of sectionKeys) {
+      const section = config[key];
+      if (isPlainObject2(section)) mergeSectionInto(key, sections[key], section, context);
+    }
+  }
+  for (const key of sectionKeys) {
+    if (Object.keys(sections[key]).length > 0) result[key] = sections[key];
+  }
+  if (result.theme?.tokens) normalizeNestedTokens(result.theme.tokens, tracker);
+  return result;
+}
+function mergeSectionInto(sectionName, target, section, context) {
+  const childContext = context && { ...context, path: [sectionName] };
+  for (const [key, value] of Object.entries(section)) {
+    if (key === "extend" || value === void 0 || omitKeys2.has(key)) continue;
+    mergeValue(target, key, value, "replace", childContext);
+  }
+  if (section.extend === void 0) return;
+  if (!isPlainObject2(section.extend)) {
+    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Config section \`${sectionName}.extend\` must be an object.`);
+  }
+  for (const [key, value] of Object.entries(section.extend)) {
+    if (value === void 0 || omitKeys2.has(key)) continue;
+    mergeValue(target, key, value, "concat", childContext);
+  }
+}
+function mergeValue(target, key, value, arrayMode, context) {
+  const current = target[key];
+  const path = context?.path.concat(key);
+  if (Array.isArray(current) && Array.isArray(value)) {
+    target[key] = arrayMode === "concat" ? current.concat(clone(value)) : clone(value);
+    recordSource(context, path, value, current, arrayMode === "concat" ? "append" : "replace");
+    return;
+  }
+  if (isPlainObject2(current) && isPlainObject2(value)) {
+    recordSource(context, path, value, current, "append");
+    const childContext = context && path ? { ...context, path } : void 0;
+    for (const [childKey, childValue] of Object.entries(value)) {
+      if (childValue !== void 0 && !omitKeys2.has(childKey))
+        mergeValue(current, childKey, childValue, arrayMode, childContext);
+    }
+    return;
+  }
+  target[key] = clone(value);
+  recordSource(context, path, value, current, "replace");
+  recordNestedSources(context, path, value);
+}
+function normalizeNestedTokens(tokens, tracker) {
+  const stack = [{ value: tokens, path: ["theme", "tokens"] }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const [key, value] of Object.entries(current.value)) {
+      if (!isPlainObject2(value)) continue;
+      if (isValidToken(value)) {
+        normalizeToken(value, tracker, current.path.concat(key));
+      } else {
+        stack.push({ value, path: current.path.concat(key) });
+      }
+    }
+  }
+}
+function normalizeToken(token, tracker, path) {
+  let hasNestedKeys = false;
+  for (const key of Object.keys(token)) {
+    if (!tokenKeys2.has(key)) {
+      hasNestedKeys = true;
+      break;
+    }
+  }
+  if (!hasNestedKeys) return;
+  token.DEFAULT ||= {};
+  for (const key of tokenKeys2) {
+    if (token[key] == null) continue;
+    const moved = !token.DEFAULT[key];
+    token.DEFAULT[key] ||= token[key];
+    if (moved) tracker?.moveIfMissing(path.concat(key), path.concat("DEFAULT", key));
+    else tracker?.delete(path.concat(key));
+    delete token[key];
+  }
+}
+function isValidToken(token) {
+  return Object.hasOwnProperty.call(token, "value");
+}
+
+export {
+  PandaError,
+  isPlainObject2 as isPlainObject,
+  mergeConfigsWithSources,
+  mergeConfigs
+};

package/dist/chunk-VYX3JX5J.js

@@ -0,0 +1,106 @@
+// src/serialize.ts
+import {
+  normalizeImportMap
+} from "@pandacss/compiler-shared";
+import { stringify } from "javascript-stringify";
+
+// src/hooks.ts
+var compact = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
+function serializeHooks(config, callbacks, sanitize2, hashCallbackSource2) {
+  const parserBefore = collectPluginHookHandlers(config, "parser:before").map((entry, index) => {
+    const hook = normalizeHook(entry.value, "parser:before");
+    const id = `plugins.${entry.pluginIndex}.hooks.parser:before.${index}`;
+    callbacks["parser:before"] ??= {};
+    callbacks["parser:before"][id] = hook.handler;
+    return compact({
+      id,
+      name: entry.name,
+      filter: hook.filter ? sanitize2(
+        hook.filter,
+        ["plugins", String(entry.pluginIndex), "hooks", "parser:before", "filter"],
+        callbacks
+      ) : void 0,
+      hash: hashCallbackSource2(hook.handler)
+    });
+  });
+  return parserBefore.length > 0 ? { "parser:before": parserBefore } : void 0;
+}
+function collectPluginHookHandlers(config, name) {
+  const entries = [];
+  const plugins = [...config.plugins ?? []];
+  plugins.forEach((plugin, pluginIndex) => {
+    const value = plugin.hooks?.[name];
+    if (value) entries.push({ pluginIndex, name: plugin.name, value });
+  });
+  return entries;
+}
+function normalizeHook(value, name) {
+  if (typeof value === "function") return { handler: value };
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
+  }
+  const record = value;
+  if (typeof record.handler !== "function") {
+    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
+  }
+  return { filter: record.filter, handler: record.handler };
+}
+
+// src/serialize.ts
+var compact2 = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
+var runtimeOnlyKeys = /* @__PURE__ */ new Set(["hooks", "plugins", "presets", "name"]);
+function createConfigSnapshot(config) {
+  const callbacks = {};
+  const hooks = serializeHooks(config, callbacks, sanitize, hashCallbackSource);
+  const serialized = {
+    ...sanitize(config, [], callbacks),
+    importMap: normalizeImportMap(config)
+  };
+  attachPatternCodegenSource(serialized, config);
+  return { config: serialized, callbacks, ...hooks ? { hooks } : {} };
+}
+function sanitize(value, path, callbacks) {
+  if (typeof value === "function") return serializeFunction(value, path, callbacks);
+  if (value instanceof RegExp) return { kind: "regex", source: value.source, flags: value.flags };
+  if (Array.isArray(value)) return value.map((item, index) => sanitize(item, path.concat(String(index)), callbacks));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).filter(([key]) => path.length > 0 || !runtimeOnlyKeys.has(key)).map(([key, item]) => [key, sanitize(item, path.concat(key), callbacks)]).filter(([, item]) => item !== void 0)
+  );
+}
+function serializeFunction(fn, path, callbacks) {
+  const ref = getCallbackRef(path);
+  if (!ref) return void 0;
+  callbacks[ref.kind] ??= {};
+  callbacks[ref.kind][ref.id] = fn;
+  return { kind: "js-callback", id: ref.id, hash: hashCallbackSource(fn) };
+}
+function hashCallbackSource(fn) {
+  const source = stringify(fn) ?? String(fn);
+  let hash = 5381;
+  for (let i = source.length - 1; i >= 0; i--) hash = hash * 33 ^ source.charCodeAt(i);
+  return `fn1-${(hash >>> 0).toString(36)}`;
+}
+function getCallbackRef(path) {
+  const key = path.at(-1);
+  if (path[0] === "utilities" && key === "transform") return { kind: "utility.transform", id: path.join(".") };
+  if (path[0] === "utilities" && key === "values") return { kind: "utility.values", id: path.join(".") };
+  if (path[0] === "patterns" && key === "transform") return { kind: "pattern.transform", id: path.join(".") };
+  if (path[0] === "patterns" && key === "defaultValues") return { kind: "pattern.defaultValues", id: path.join(".") };
+}
+function attachPatternCodegenSource(serialized, config) {
+  const patterns = config.patterns;
+  const serializedPatterns = serialized.patterns;
+  if (!patterns || !serializedPatterns) return;
+  for (const [name, pattern] of Object.entries(patterns)) {
+    if (typeof pattern?.transform !== "function") continue;
+    const source = stringify(compact2({ transform: pattern.transform, defaultValues: pattern.defaultValues })) ?? "";
+    if (serializedPatterns[name]) serializedPatterns[name].codegenSource = source;
+  }
+}
+
+export {
+  collectPluginHookHandlers,
+  normalizeHook,
+  createConfigSnapshot
+};

package/dist/index.d.ts

@@ -1,59 +1,84 @@
-import * as _pandacss_types from '@pandacss/types';
-import { Config, ConfigTsOptions, PandaHooks, LoadConfigResult } from '@pandacss/types';
-export { diffConfigs } from './diff-config.js';
-import { TSConfig } from 'pkg-types';
-import { P as PathMapping } from './ts-config-paths-qwrwgu2Q.js';
-export { c as convertTsPathsToRegexes } from './ts-config-paths-qwrwgu2Q.js';
-export { mergeConfigs, mergeHooks } from './merge-config.js';
+import { SerializedConfig, ProjectCallbacks, ProjectHooks, ConfigSnapshot, DiffConfigResult } from '@pandacss/compiler-shared';
+export { DiffConfigResult } from '@pandacss/compiler-shared';
+import { HookRegistry, Config } from '@pandacss/types';
+import { C as ConfigSources } from './merge-Bt4BM1CH.js';
+export { a as ConfigSourceEntry, m as mergeConfigs } from './merge-Bt4BM1CH.js';
+export { ConfigSnapshot, createConfigSnapshot } from './serialize.js';
 
-interface ConfigFileOptions {
+interface PluginHookEntry<Name extends keyof HookRegistry> {
+    pluginIndex: number;
+    name: string | undefined;
+    value: HookRegistry[Name];
+}
+type HostHooks = {
+    'codegen:prepare'?: Array<PluginHookEntry<'codegen:prepare'>>;
+    'codegen:done'?: Array<PluginHookEntry<'codegen:done'>>;
+};
+
+interface LoadConfigOptions {
     cwd: string;
+    /** Explicit config file path (relative to `cwd`); otherwise discovered upward. */
     file?: string;
+    /** Track which authored config or preset contributed resolved config entries. */
+    trackSources?: boolean;
 }
-interface BundleConfigResult<T = Config> {
-    config: T;
-    dependencies: string[];
+interface LoadConfigResult {
+    /** Absolute path to the resolved config file. */
     path: string;
+    /** JSON-safe, callback-lowered config; patterns carry `codegenSource`. */
+    config: SerializedConfig;
+    /** Live utility/pattern transform callbacks, paired with `config`. */
+    callbacks: ProjectCallbacks;
+    /** JSON-safe hot-path hook metadata paired with live callbacks. */
+    hooks?: ProjectHooks;
+    /** Live JS host hooks that do not cross into Rust. */
+    hostHooks?: HostHooks;
+    /** Module ids the config depends on, for watch-mode invalidation. */
+    dependencies: string[];
+    metadata?: {
+        sources?: ConfigSources;
+    };
 }
 
-declare function bundleConfig(options: ConfigFileOptions): Promise<BundleConfigResult>;
-
-declare function findConfig(options: Partial<ConfigFileOptions>): string;
-
-interface GetDepsOptions {
-    filename: string;
-    ext: string;
-    cwd: string;
-    seen: Set<string>;
-    baseUrl: string | undefined;
-    pathMappings: PathMapping[];
-    foundModuleAliases: Map<string, string>;
-    compilerOptions?: TSConfig['compilerOptions'];
-}
-declare function getConfigDependencies(filePath: string, tsOptions?: ConfigTsOptions, compilerOptions?: TSConfig['compilerOptions']): {
-    deps: Set<string>;
-    aliases: Map<string, string>;
-};
-
-type Extendable<T> = T & {
-    extend?: T;
-};
-type ExtendableConfig = Extendable<Config>;
 /**
- * Recursively merge all presets into a single config (depth-first using stack)
+ * Load and serialize a user's Panda config into a compiler-ready snapshot.
+ * Bundles in memory (Rolldown + `data:` URL), then lowers functions to callback
+ * refs and captures pattern transform source. The result feeds
+ * `createCompilerFromSnapshot({ config, callbacks })`.
+ *
+ * Authored presets are resolved before defaults are applied; live hooks remain
+ * in the JS host and only parser:before metadata crosses into Rust.
  */
-declare function getResolvedConfig(config: ExtendableConfig, cwd: string, hooks?: Partial<PandaHooks>): Promise<Config>;
+declare function loadConfig(options: LoadConfigOptions): Promise<LoadConfigResult>;
 
 /**
- * Find, load and resolve the final config (including presets)
+ * Structurally diff two serialized configs and map each change to the coarse
+ * `CodegenDependency` bits the Rust engine regenerates by. Ported from v1's
+ * `diffConfigs` (`packages/config/src/diff-config.ts`), but targeting the
+ * engine's `generateAffectedArtifacts(CodegenDependency[])` seam rather than v1's
+ * per-file `ArtifactId` set.
+ *
+ * Callback refs carry a source hash, and hook filters are serialized data in
+ * the optional `hooks` snapshot, so callback and filter edits remain visible to
+ * this structural diff.
  */
-declare function loadConfig(options: ConfigFileOptions): Promise<_pandacss_types.LoadConfigResult>;
+declare function diffConfig(prev: SerializedConfig | ConfigSnapshot | undefined, next: SerializedConfig | ConfigSnapshot): DiffConfigResult;
+
+/** Locate the user's `panda.config.{ts,js,…}`, walking up from `cwd`. */
+declare function findConfig(options: {
+    cwd: string;
+    file?: string;
+}): string;
 
+interface BundleConfigResult<T = Config> {
+    config: T;
+    dependencies: string[];
+}
 /**
- * Resolve the final config (including presets)
- * @pandacss/preset-base: ALWAYS included if NOT using eject: true
- * @pandacss/preset-panda: only included by default if no presets
+ * Bundle a config (or preset) module in memory with Rolldown and evaluate it via
+ * a `data:` URL — no temp file is written. Mirrors the legacy in-memory loader
+ * without re-adding `bundle-n-require`.
  */
-declare function resolveConfig(result: BundleConfigResult, cwd: string): Promise<LoadConfigResult>;
+declare function bundleConfig<T extends Config = Config>(filepath: string, cwd: string): Promise<BundleConfigResult<T>>;
 
-export { type BundleConfigResult, type GetDepsOptions, bundleConfig, findConfig, getConfigDependencies, getResolvedConfig, loadConfig, resolveConfig };
+export { type BundleConfigResult, ConfigSources, type LoadConfigOptions, type LoadConfigResult, bundleConfig, diffConfig, findConfig, loadConfig };