@pandacss/config 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/{chunk-LUSBBUHX.js → chunk-LDC4ZCDS.js}

@@ -1,13 +1,9 @@
-// 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;
-  }
-};
+import {
+  PandaError,
+  clone,
+  isPlainObject,
+  omitKeys
+} from "./chunk-R4R5RHIS.js";
 
 // src/sources.ts
 var sectionKeySet = /* @__PURE__ */ new Set([
@@ -18,11 +14,9 @@ var sectionKeySet = /* @__PURE__ */ new Set([
   "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([
@@ -33,7 +27,8 @@ var themeEntryKeys = /* @__PURE__ */ new Set([
   "layerStyles",
   "recipes",
   "slotRecipes",
-  "textStyles"
+  "textStyles",
+  "viewTransitions"
 ]);
 var SourceTracker = class {
   sources;
@@ -101,30 +96,6 @@ function shouldTrackThemePath(rest, value, current) {
   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 = [
@@ -135,13 +106,24 @@ var sectionKeys = [
   "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"]);
+var themeRegistryKeys = /* @__PURE__ */ new Set([
+  "tokens",
+  "semanticTokens",
+  "keyframes",
+  "recipes",
+  "slotRecipes",
+  "textStyles",
+  "layerStyles",
+  "animationStyles",
+  "viewTransitions",
+  "positionTry"
+]);
 function mergeConfigsWithSources(configs) {
   const tracker = new SourceTracker(configs.map((item) => item.source));
   const config = mergeConfigs(configs, tracker);
@@ -154,13 +136,15 @@ function mergeConfigs(configs, tracker) {
     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;
+      if (value === void 0 || sectionKeySet2.has(key) || runtimeOnlyKeys.has(key) || omitKeys.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);
+      if (!isPlainObject(section)) continue;
+      applySectionBase(key, sections[key], section, context);
+      applySectionExtend(key, sections[key], section, context);
     }
   }
   for (const key of sectionKeys) {
@@ -169,21 +153,45 @@ function mergeConfigs(configs, tracker) {
   if (result.theme?.tokens) normalizeNestedTokens(result.theme.tokens, tracker);
   return result;
 }
-function mergeSectionInto(sectionName, target, section, context) {
+function applySectionBase(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 (key === "extend" || value === void 0 || omitKeys.has(key)) continue;
+    if (isRegistry(sectionName, key, value)) {
+      replaceRegistryEntries(target, key, value, childContext);
+    } else {
+      replaceValue(target, key, value, childContext);
+    }
+  }
+}
+function isRegistry(sectionName, key, value) {
+  return sectionName === "theme" && themeRegistryKeys.has(key) && isPlainObject(value);
+}
+function replaceRegistryEntries(target, key, registry, context) {
+  const entries = isPlainObject(target[key]) ? target[key] : target[key] = {};
+  const entryContext = context && { ...context, path: context.path.concat(key) };
+  for (const [name, value] of Object.entries(registry)) {
+    if (value === void 0 || omitKeys.has(name)) continue;
+    replaceValue(entries, name, value, entryContext);
   }
+}
+function applySectionExtend(sectionName, target, section, context) {
   if (section.extend === void 0) return;
-  if (!isPlainObject2(section.extend)) {
+  if (!isPlainObject(section.extend)) {
     throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Config section \`${sectionName}.extend\` must be an object.`);
   }
+  const childContext = context && { ...context, path: [sectionName] };
   for (const [key, value] of Object.entries(section.extend)) {
-    if (value === void 0 || omitKeys2.has(key)) continue;
+    if (value === void 0 || omitKeys.has(key)) continue;
     mergeValue(target, key, value, "concat", childContext);
   }
 }
+function replaceValue(target, key, value, context) {
+  const path = context?.path.concat(key);
+  recordSource(context, path, value, target[key], "replace");
+  target[key] = clone(value);
+  recordNestedSources(context, path, value);
+}
 function mergeValue(target, key, value, arrayMode, context) {
   const current = target[key];
   const path = context?.path.concat(key);
@@ -192,11 +200,11 @@ function mergeValue(target, key, value, arrayMode, context) {
     recordSource(context, path, value, current, arrayMode === "concat" ? "append" : "replace");
     return;
   }
-  if (isPlainObject2(current) && isPlainObject2(value)) {
+  if (isPlainObject(current) && isPlainObject(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))
+      if (childValue !== void 0 && !omitKeys.has(childKey))
         mergeValue(current, childKey, childValue, arrayMode, childContext);
     }
     return;
@@ -210,7 +218,7 @@ function normalizeNestedTokens(tokens, tracker) {
   while (stack.length > 0) {
     const current = stack.pop();
     for (const [key, value] of Object.entries(current.value)) {
-      if (!isPlainObject2(value)) continue;
+      if (!isPlainObject(value)) continue;
       if (isValidToken(value)) {
         normalizeToken(value, tracker, current.path.concat(key));
       } else {
@@ -243,8 +251,6 @@ function isValidToken(token) {
 }
 
 export {
-  PandaError,
-  isPlainObject2 as isPlainObject,
   mergeConfigsWithSources,
   mergeConfigs
 };

package/dist/chunk-R4R5RHIS.js

@@ -0,0 +1,73 @@
+// src/error.ts
+var PandaError = class extends Error {
+  code;
+  hint;
+  diagnostics;
+  constructor(code, message, opts) {
+    super(message, { cause: opts?.cause });
+    this.code = `ERR_PANDA_${code}`;
+    this.hint = opts?.hint;
+    this.diagnostics = opts?.diagnostics;
+  }
+};
+function createConfigError(message, diagnostics) {
+  return new PandaError("CONFIG_ERROR", `\u{1F4A5} ${message}`, { diagnostics });
+}
+function createConfigDiagnostic(code, message, help) {
+  return {
+    code,
+    message,
+    severity: "error",
+    category: "config",
+    ...help ? { help } : {}
+  };
+}
+
+// src/shared.ts
+var omitKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(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)) {
+    const len = value.length;
+    const out2 = new Array(len);
+    for (let i = 0; i < len; i++) out2[i] = clone(value[i]);
+    return out2;
+  }
+  if (!isPlainObject(value)) return value;
+  const source = value;
+  const out = {};
+  const keys = Object.keys(source);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (omitKeys.has(key)) continue;
+    const item = source[key];
+    if (item !== void 0) out[key] = clone(item);
+  }
+  return out;
+}
+function ensureConfigObject(config, name) {
+  if (isPlainObject(config)) return config;
+  throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Preset ${JSON.stringify(name)} must resolve to an object.`);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
+}
+
+export {
+  PandaError,
+  createConfigError,
+  createConfigDiagnostic,
+  omitKeys,
+  isPlainObject,
+  clone,
+  ensureConfigObject,
+  errorMessage,
+  compact
+};

package/dist/{chunk-VYX3JX5J.js → chunk-Y642H6DU.js}

@@ -1,3 +1,9 @@
+import {
+  compact,
+  createConfigError,
+  isPlainObject
+} from "./chunk-R4R5RHIS.js";
+
 // src/serialize.ts
 import {
   normalizeImportMap
@@ -5,7 +11,6 @@ import {
 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");
@@ -46,10 +51,55 @@ function normalizeHook(value, name) {
   return { filter: record.filter, handler: record.handler };
 }
 
+// src/utility-global-vars.ts
+function mergeUtilityGlobalVars(config) {
+  const utilities = config.utilities;
+  if (!isPlainObject(utilities)) return config;
+  const merged = {};
+  const owners = /* @__PURE__ */ new Map();
+  let found = false;
+  const nextUtilities = {};
+  for (const [name, utility] of Object.entries(utilities)) {
+    if (!isPlainObject(utility) || !isPlainObject(utility.globalVars)) {
+      nextUtilities[name] = utility;
+      continue;
+    }
+    found = true;
+    const { globalVars, ...rest } = utility;
+    nextUtilities[name] = rest;
+    for (const [key, definition] of Object.entries(globalVars)) {
+      const previous = merged[key];
+      if (previous !== void 0 && !isSameDefinition(previous, definition)) {
+        throw createConfigError(
+          `The \`${owners.get(key)}\` and \`${name}\` utilities both register \`${key}\`, with different definitions.
+A CSS variable has one registration for the whole document, so share one definition between them.`
+        );
+      }
+      merged[key] = definition;
+      owners.set(key, name);
+    }
+  }
+  if (!found) return config;
+  const configVars = isPlainObject(config.globalVars) ? config.globalVars : {};
+  return {
+    ...config,
+    utilities: nextUtilities,
+    globalVars: { ...merged, ...configVars },
+    utilityGlobalVars: Object.fromEntries(owners)
+  };
+}
+function isSameDefinition(a, b) {
+  if (a === b) return true;
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => a[key] === b[key]);
+}
+
 // 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) {
+function createConfigSnapshot(input) {
+  const config = mergeUtilityGlobalVars(input);
   const callbacks = {};
   const hooks = serializeHooks(config, callbacks, sanitize, hashCallbackSource);
   const serialized = {
@@ -94,7 +144,7 @@ function attachPatternCodegenSource(serialized, config) {
   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 })) ?? "";
+    const source = stringify(compact({ transform: pattern.transform, defaultValues: pattern.defaultValues })) ?? "";
     if (serializedPatterns[name]) serializedPatterns[name].codegenSource = source;
   }
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { SerializedConfig, ProjectCallbacks, ProjectHooks, ConfigSnapshot, DiffConfigResult } from '@pandacss/compiler-shared';
+import { DesignSystemManifest, CodegenOverlay, Diagnostic, SerializedConfig, ProjectCallbacks, ProjectHooks, ConfigSnapshot, DiffConfigResult, DesignSystemManifestImportMap } 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';
+import { HookRegistry, Config, UserConfig } from '@pandacss/types';
+import { C as ConfigSources } from './merge-EXcM0jFd.js';
+export { a as ConfigSourceEntry, m as mergeConfigs } from './merge-EXcM0jFd.js';
 export { ConfigSnapshot, createConfigSnapshot } from './serialize.js';
 
 interface PluginHookEntry<Name extends keyof HookRegistry> {
@@ -13,8 +13,49 @@ interface PluginHookEntry<Name extends keyof HookRegistry> {
 type HostHooks = {
     'codegen:prepare'?: Array<PluginHookEntry<'codegen:prepare'>>;
     'codegen:done'?: Array<PluginHookEntry<'codegen:done'>>;
+    'cssgen:done'?: Array<PluginHookEntry<'cssgen:done'>>;
 };
 
+interface DesignSystemOverlayInput {
+    authored: {
+        conditions: boolean;
+        breakpoints: boolean;
+        utilities: boolean;
+        tokens: boolean;
+    };
+    compatible: boolean;
+}
+
+interface ResolvedDesignSystem {
+    name: string;
+    specifier: string;
+    manifest: DesignSystemManifest;
+    manifestPath: string;
+    buildInfoPath: string;
+    files: string[];
+    tokenPaths: string[];
+    recipeNames: string[];
+    patternNames: string[];
+    importMap?: DesignSystemManifest['importMap'];
+    packageExports?: Record<string, unknown>;
+    optionMismatch?: string[];
+}
+interface DesignSystemMetadata {
+    designSystem?: ResolvedDesignSystem[];
+    userRecipeNames?: string[];
+    userPatternNames?: string[];
+    overlayInput?: DesignSystemOverlayInput;
+}
+declare function buildCodegenOverlay(metadata: DesignSystemMetadata | undefined): CodegenOverlay | undefined;
+interface DesignSystemArtifactConflict {
+    name: string;
+    recipes: string[];
+    patterns: string[];
+}
+declare function collectArtifactConflicts(metadata: DesignSystemMetadata | undefined): DesignSystemArtifactConflict[];
+declare function collectExportMissingDiagnostics(metadata: DesignSystemMetadata | undefined): Diagnostic[];
+declare function collectNameCollisionDiagnostics(metadata: DesignSystemMetadata | undefined): Diagnostic[];
+
 interface LoadConfigOptions {
     cwd: string;
     /** Explicit config file path (relative to `cwd`); otherwise discovered upward. */
@@ -37,6 +78,11 @@ interface LoadConfigResult {
     dependencies: string[];
     metadata?: {
         sources?: ConfigSources;
+        designSystem?: ResolvedDesignSystem[];
+        userTokenPaths?: string[];
+        userRecipeNames?: string[];
+        userPatternNames?: string[];
+        overlayInput?: DesignSystemOverlayInput;
     };
 }
 
@@ -81,4 +127,82 @@ interface BundleConfigResult<T = Config> {
  */
 declare function bundleConfig<T extends Config = Config>(filepath: string, cwd: string): Promise<BundleConfigResult<T>>;
 
-export { type BundleConfigResult, ConfigSources, type HostHooks, type LoadConfigOptions, type LoadConfigResult, bundleConfig, diffConfig, findConfig, loadConfig };
+declare function readPandaVersion(): string | undefined;
+declare function getPandaMajorRange(): string | undefined;
+declare function isStampablePandaRange(range: string | undefined): range is string;
+
+interface CompilePresetResult {
+    code: string;
+    dependencies: string[];
+}
+interface CompilePresetOptions {
+    configPath: string;
+    cwd: string;
+}
+declare function compilePreset(options: CompilePresetOptions): Promise<CompilePresetResult>;
+
+interface PackageIdentity {
+    name: string;
+    version?: string;
+    pandaPeer?: string;
+    packagePath: string;
+    /** package.json `"files"` when it's a string array; used for lib fallback publish checks. */
+    publishFiles?: string[];
+}
+declare function resolvePublishedPandaRange(range: string | undefined, currentVersion: string | undefined): string;
+declare function readPackageIdentity(cwd: string): PackageIdentity;
+declare function defaultImportMap(name: string): DesignSystemManifestImportMap;
+interface SyncExportsResult {
+    changed: boolean;
+    json: string;
+    /** Existing subpaths whose value differed from the one Panda wrote (overwritten). */
+    conflicts: string[];
+}
+interface SyncExportsOptions {
+    packageJson: string;
+    entries: Record<string, unknown>;
+}
+declare function syncExports(options: SyncExportsOptions): SyncExportsResult;
+
+interface FilterPublishableLibFilesOptions {
+    /** Fallback paths relative to the lib outdir (same form as manifest `files`). */
+    files: string[];
+    packageRoot: string;
+    /** Lib outdir — resolve `files` entries from here. */
+    outRoot: string;
+    /** package.json `"files"`; omit when the whole package is packed. */
+    publishFiles?: string[];
+}
+interface FilterPublishableLibFilesResult {
+    files: string[];
+    unpublished: string[];
+}
+/**
+ * Drop inferred lib fallback paths that would not ship in the npm tarball when
+ * package.json `"files"` is set. Explicit `--files` should skip this filter.
+ *
+ * Runs once at `panda lib` time (not on consume/cssgen). Patterns are compiled
+ * once per call; the common `"files": ["dist"]` case is prefix-only.
+ */
+declare function filterPublishableLibFiles(options: FilterPublishableLibFilesOptions): FilterPublishableLibFilesResult;
+/** Read package.json `"files"` when it is a non-empty string array. */
+declare function readPublishFilesField(value: unknown): string[] | undefined;
+
+interface SmartIncludeResult {
+    include: string[];
+    excludes: string[];
+    changed: boolean;
+}
+declare function resolveSmartInclude(include: string[], cwd: string, deps: Set<string>): SmartIncludeResult;
+declare function mergeExcludes(existing: string[] | undefined, additions: string[]): string[];
+
+declare function collectTokenPaths(config: Pick<UserConfig, 'theme'> | undefined): string[];
+
+declare function toPosixPath(path: string): string;
+declare function toPosixRelative(from: string, to: string): string;
+declare function toRelativeKey(key: string, cwd: string): string;
+
+declare function collectRecipeNames(config: Pick<UserConfig, 'theme'> | undefined): string[];
+declare function collectPatternNames(config: Pick<UserConfig, 'patterns'> | undefined): string[];
+
+export { type BundleConfigResult, type CompilePresetOptions, type CompilePresetResult, ConfigSources, type DesignSystemArtifactConflict, type DesignSystemMetadata, type DesignSystemOverlayInput, type FilterPublishableLibFilesOptions, type FilterPublishableLibFilesResult, type HostHooks, type LoadConfigOptions, type LoadConfigResult, type PackageIdentity, type ResolvedDesignSystem, type SyncExportsOptions, type SyncExportsResult, buildCodegenOverlay, bundleConfig, collectArtifactConflicts, collectExportMissingDiagnostics, collectNameCollisionDiagnostics, collectPatternNames, collectRecipeNames, collectTokenPaths, compilePreset, defaultImportMap, diffConfig, filterPublishableLibFiles, findConfig, getPandaMajorRange, isStampablePandaRange, loadConfig, mergeExcludes, readPackageIdentity, readPandaVersion, readPublishFilesField, resolvePublishedPandaRange, resolveSmartInclude, syncExports, toPosixPath, toPosixRelative, toRelativeKey };