@pandacss/compiler 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/chunk-7OM4CBA4.js

@@ -1,515 +0,0 @@
-// src/index.ts
-import {
-  assertProjectHooks,
-  assertProjectCallbacks,
-  getTokenCategoryValues,
-  makeBuildInfoApi as makeBuildInfoApi2,
-  mergeCallbacks,
-  mergeHooks,
-  prepareCompilerConfig
-} from "@pandacss/compiler-shared";
-
-// src/callbacks.ts
-import {
-  createPatternHelpers,
-  createTransformArgs,
-  getPatternDefaultValueRefsByTransformId,
-  mergePatternDefaultValues
-} from "@pandacss/compiler-shared";
-function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
-  const utilityTransforms = callbacks["utility.transform"];
-  const hasUtilityTransforms = !!utilityTransforms && Object.keys(utilityTransforms).length > 0;
-  const patternTransforms = callbacks["pattern.transform"];
-  const hasPatternTransforms = !!patternTransforms && Object.keys(patternTransforms).length > 0;
-  const config = project.config();
-  const patternDefaultValues = callbacks["pattern.defaultValues"];
-  const patternDefaultValueRefs = config && patternDefaultValues ? getPatternDefaultValueRefsByTransformId(config) : /* @__PURE__ */ new Map();
-  if (hasPatternTransforms && !project.registerPatternTransform) {
-    throw new Error("Native project does not support pattern.transform callbacks");
-  }
-  if (project.registerPatternTransform && patternTransforms) {
-    for (const [id, callback] of Object.entries(patternTransforms)) {
-      const defaultValueId = patternDefaultValueRefs.get(id);
-      const defaultValue = defaultValueId ? patternDefaultValues?.[defaultValueId] : void 0;
-      project.registerPatternTransform(id, (props) => {
-        const input = props;
-        const nextProps = defaultValue ? mergePatternDefaultValues(defaultValue(input), input) : input;
-        return callback(nextProps, createPatternHelpers());
-      });
-    }
-  }
-  if (hasUtilityTransforms && !project.registerUtilityTransform) {
-    throw new Error("Native project does not support utility.transform callbacks");
-  }
-  if (project.registerUtilityTransform && utilityTransforms) {
-    for (const [id, callback] of Object.entries(utilityTransforms)) {
-      project.registerUtilityTransform(id, (resolved, original) => {
-        return callback(resolved, createTransformArgs(original, tokenDictionary));
-      });
-    }
-  }
-  const sourceTransforms = hooks?.["parser:before"];
-  if (sourceTransforms?.length && !project.registerSourceTransform) {
-    throw new Error("Native project does not support parser:before callbacks");
-  }
-  if (project.registerSourceTransform && sourceTransforms) {
-    for (const hook of sourceTransforms) {
-      const callback = callbacks["parser:before"]?.[hook.id];
-      if (!callback) continue;
-      project.registerSourceTransform(hook.id, hook.filter, (filePath, content) => {
-        const result = callback({ filePath: String(filePath), content: String(content), original: String(content) });
-        if (isPromiseLike(result)) {
-          throw new Error(`parser:before callback \`${hook.id}\` must be synchronous`);
-        }
-        return typeof result === "string" ? result : void 0;
-      });
-    }
-  }
-}
-function isPromiseLike(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-
-// src/fallback.ts
-import { makeBuildInfoApi } from "@pandacss/compiler-shared";
-var fallbackBuildInfo = makeBuildInfoApi({
-  serializeBuildInfo: () => ({
-    schemaVersion: -1,
-    panda: "",
-    configFingerprint: "",
-    strings: [],
-    atoms: [],
-    modules: {}
-  }),
-  applyBuildInfo: () => false,
-  buildInfoSchemaVersion: () => -1,
-  configFingerprint: () => ""
-});
-var FallbackExtractor = class {
-  extract() {
-    return { calls: [], jsx: [], diagnostics: [] };
-  }
-  extractDebug() {
-    return { imports: [], matched: [], calls: [], jsx: [], diagnostics: [] };
-  }
-  matchImports() {
-    return [];
-  }
-};
-var FallbackCompiler = class _FallbackCompiler {
-  static fromConfig() {
-    return new _FallbackCompiler();
-  }
-  config() {
-    return {};
-  }
-  extractFileSource() {
-    return { calls: [], jsx: [], diagnostics: [] };
-  }
-  parseFile(path) {
-    return { path, cssCalls: 0, cvaCalls: 0, svaCalls: 0, jsxUsages: 0, diagnostics: [] };
-  }
-  parseFileSource(path) {
-    return { path, cssCalls: 0, cvaCalls: 0, svaCalls: 0, jsxUsages: 0, diagnostics: [] };
-  }
-  refreshFile() {
-    return false;
-  }
-  refreshFileSource() {
-    return false;
-  }
-  removeFile() {
-    return false;
-  }
-  clear() {
-  }
-  scan() {
-    return [];
-  }
-  realpath(path) {
-    return path;
-  }
-  resolvePath(path, cwd) {
-    if (!cwd || path.startsWith("/")) return path;
-    return `${cwd.replace(/\/$/, "")}/${path}`;
-  }
-  joinPath(parts) {
-    return parts.filter(Boolean).join("/");
-  }
-  dirname(path) {
-    const index = path.lastIndexOf("/");
-    return index <= 0 ? "" : path.slice(0, index);
-  }
-  isSourceFile() {
-    return false;
-  }
-  parseFiles(_paths) {
-    return [];
-  }
-  layers() {
-    return { reset: "reset", base: "base", tokens: "tokens", recipes: "recipes", utilities: "utilities" };
-  }
-  hasLayerDeclaration() {
-    return false;
-  }
-  spec() {
-    return {
-      conditions: { keys: [], breakpoints: [], containers: [] },
-      tokens: { categories: {}, colorPalettes: [], values: {}, deprecated: [] },
-      utilities: { properties: {}, shorthands: {}, deprecated: [] },
-      patterns: { patterns: {} },
-      recipes: { recipes: {}, slotRecipes: {} },
-      propertyOrder: []
-    };
-  }
-  sources() {
-    return [];
-  }
-  inspectFileSource() {
-    return { usages: [], diagnostics: [] };
-  }
-  writeArtifacts() {
-    return [];
-  }
-  writeCss(outfile) {
-    return {
-      path: outfile,
-      css: "",
-      manifest: { files: [], tokens: [] },
-      layerRanges: {},
-      diagnostics: []
-    };
-  }
-  writeSplitCss(outdir) {
-    return {
-      root: outdir,
-      paths: [],
-      files: []
-    };
-  }
-  isEmpty() {
-    return true;
-  }
-  atoms() {
-    return [];
-  }
-  recipes() {
-    return [];
-  }
-  slotRecipes() {
-    return [];
-  }
-  encodedRecipes() {
-    return { base: [], variants: [], atomic: [] };
-  }
-  staticPatternAtoms() {
-    return { atoms: [], diagnostics: [] };
-  }
-  getFile() {
-    return null;
-  }
-  fileManifest() {
-    return [];
-  }
-  summary() {
-    return { filesProcessed: 0, atomCount: 0, recipeCount: 0, slotRecipeCount: 0 };
-  }
-  compile() {
-    return {
-      css: "",
-      manifest: { files: [], tokens: [] },
-      layerRanges: {},
-      diagnostics: []
-    };
-  }
-  layerCss() {
-    return "";
-  }
-  splitCss() {
-    return [];
-  }
-  buildInfo = fallbackBuildInfo;
-  generateArtifacts() {
-    return [];
-  }
-  generateArtifact() {
-    return void 0;
-  }
-  generateAffectedArtifacts() {
-    return [];
-  }
-  diagnostics() {
-    return [];
-  }
-};
-var fallback = {
-  startTracing() {
-    return false;
-  },
-  flushTracing() {
-  },
-  shutdownTracing() {
-    return false;
-  },
-  compile() {
-    return {
-      css: "",
-      manifest: { files: [], tokens: [] },
-      layerRanges: {},
-      diagnostics: []
-    };
-  },
-  scanImports() {
-    return { imports: [], diagnostics: [] };
-  },
-  matchImports() {
-    return [];
-  },
-  extractCalls() {
-    return { calls: [], diagnostics: [] };
-  },
-  extractJsx() {
-    return { jsx: [], diagnostics: [] };
-  },
-  extract() {
-    return { calls: [], jsx: [], diagnostics: [] };
-  },
-  extractDebug() {
-    return { imports: [], matched: [], calls: [], jsx: [], diagnostics: [] };
-  },
-  Extractor: FallbackExtractor,
-  Compiler: FallbackCompiler
-};
-
-// src/load-binary.ts
-import { existsSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import { join } from "path";
-import { fileURLToPath } from "url";
-var bindingUrl = new URL("../binding.cjs", import.meta.url);
-function loadNativeBinding() {
-  const bindingPath = resolveBindingPath();
-  if (!bindingPath) return void 0;
-  const require2 = createRequire(bindingPath);
-  return require2(bindingPath);
-}
-function resolveBindingPath() {
-  if (bindingUrl.protocol === "file:") {
-    const bindingPath = fileURLToPath(bindingUrl);
-    if (existsSync(bindingPath)) return bindingPath;
-  }
-  return fallbackBindingPaths().find((path) => existsSync(path));
-}
-function fallbackBindingPaths() {
-  const cwd = process.cwd();
-  const paths = [join(cwd, "packages/compiler/binding.cjs")];
-  if (isCompilerPackageRoot(cwd)) {
-    paths.unshift(join(cwd, "binding.cjs"));
-  }
-  return paths;
-}
-function isCompilerPackageRoot(cwd) {
-  try {
-    const packageJson = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
-    return packageJson.name === "@pandacss/compiler";
-  } catch {
-    return false;
-  }
-}
-
-// src/driver.ts
-import {
-  BaseDriver
-} from "@pandacss/compiler-shared";
-import { diffConfig, loadConfig } from "@pandacss/config";
-import { mkdirSync, writeFileSync } from "fs";
-import { isAbsolute, join as join2 } from "path";
-async function createNodeDriver(options) {
-  const loaded = await loadConfig({ cwd: options.cwd, file: options.configPath });
-  return new NodeDriver(options, loaded);
-}
-var NodeDriver = class extends BaseDriver {
-  #options;
-  #loaded;
-  constructor(options, loaded) {
-    super(buildFromConfig(loaded));
-    this.#options = options;
-    this.#loaded = loaded;
-  }
-  get config() {
-    return this.#loaded.config;
-  }
-  get configPath() {
-    return this.#loaded.path;
-  }
-  get configDependencies() {
-    return this.#loaded.dependencies;
-  }
-  async reload() {
-    const next = await loadConfig({ cwd: this.#options.cwd, file: this.#options.configPath });
-    const diff = diffConfig(this.#loaded, next);
-    if (diff.hasChanged) {
-      this.#loaded = next;
-      this.setCompiler(buildFromConfig(next));
-    }
-    return diff;
-  }
-  applyChange(change) {
-    if (change.kind === "unlink") {
-      return this.compiler.removeFile(change.path);
-    }
-    if (change.kind === "change") {
-      if (change.content == null) {
-        if (this.compiler.refreshFile(change.path)) return true;
-        this.compiler.parseFile(change.path);
-        return true;
-      }
-      if (this.compiler.refreshFileSource(change.path, change.content)) return true;
-      this.compiler.parseFileSource(change.path, change.content);
-      return true;
-    }
-    if (change.content == null) {
-      this.compiler.parseFile(change.path);
-      return true;
-    }
-    this.compiler.parseFileSource(change.path, change.content);
-    return true;
-  }
-  getOutdir(outdir) {
-    return this.compiler.resolvePath(this.getConfiguredOutdir(outdir));
-  }
-  codegen(options) {
-    const outdir = this.getOutdir(options?.outdir);
-    const cwd = options?.cwd ?? this.#options.cwd;
-    const prepareHooks = this.#loaded.hostHooks?.["codegen:prepare"] ?? [];
-    const doneHooks = this.#loaded.hostHooks?.["codegen:done"] ?? [];
-    const files = prepareHooks.length > 0 ? this.codegenWithPrepareHooks(prepareHooks, outdir, cwd, options) : super.codegen(options);
-    for (const entry of doneHooks) {
-      const handler = resolveHookHandler(entry.value, "codegen:done");
-      handler({ files, outdir, cwd });
-    }
-    return files;
-  }
-  codegenWithPrepareHooks(hooks, outdir, cwd, options) {
-    const artifactOptions = options?.forceImportExtension === void 0 ? void 0 : { forceImportExtension: options.forceImportExtension };
-    let artifacts = this.compiler.generateArtifacts(artifactOptions);
-    for (const entry of hooks ?? []) {
-      const handler = resolveHookHandler(entry.value, "codegen:prepare");
-      const next = handler({ artifacts, outdir, cwd });
-      if (next !== void 0) {
-        if (!Array.isArray(next)) {
-          throw new Error("Invalid codegen:prepare hook result. Expected an artifact array or undefined.");
-        }
-        artifacts = next;
-      }
-    }
-    return writeArtifacts(this.compiler, outdir, artifacts);
-  }
-  isConfigFile(file) {
-    const target = this.compiler.realpath(file);
-    if (this.compiler.realpath(this.#loaded.path) === target) return true;
-    return this.#loaded.dependencies.some((dep) => this.compiler.realpath(join2(this.#options.cwd, dep)) === target);
-  }
-};
-function resolveHookHandler(value, name) {
-  if (typeof value === "function") return value;
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
-  }
-  const handler = value.handler;
-  if (typeof handler !== "function") {
-    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
-  }
-  return handler;
-}
-function writeArtifacts(compiler, outdir, artifacts) {
-  const written = [];
-  for (const artifact of artifacts) {
-    for (const file of artifact.files) {
-      if (isAbsolute(file.path)) {
-        throw new Error(`artifact output path must be relative: ${file.path}`);
-      }
-      const target = compiler.joinPath([outdir, file.path]);
-      const parent = compiler.dirname(target);
-      if (parent) mkdirSync(parent, { recursive: true });
-      writeFileSync(target, file.code);
-      written.push(target);
-    }
-  }
-  return written;
-}
-function buildFromConfig(loaded) {
-  return createCompilerFromSnapshot({ config: loaded.config, callbacks: loaded.callbacks, hooks: loaded.hooks });
-}
-
-// src/index.ts
-var binding = loadNativeBinding() ?? fallback;
-var nativeCompilerFromConfig = "fromConfig" in binding.Compiler && typeof binding.Compiler.fromConfig === "function" ? binding.Compiler.fromConfig.bind(binding.Compiler) : void 0;
-function compile(input) {
-  return binding.compile(input);
-}
-function startTracing(options) {
-  return binding.startTracing?.(options) ?? false;
-}
-function flushTracing() {
-  binding.flushTracing?.();
-}
-function shutdownTracing() {
-  return binding.shutdownTracing?.() ?? false;
-}
-function createCompiler(config, options) {
-  return build(config, options?.callbacks ?? {}, options);
-}
-function createCompilerFromSnapshot(snapshot, options) {
-  const callbacks = mergeCallbacks(snapshot.callbacks, options?.callbacks);
-  const hooks = mergeHooks(snapshot.hooks, options?.hooks);
-  return build(snapshot.config, callbacks, { ...options, hooks });
-}
-function getBindingInfo() {
-  return {
-    native: binding !== fallback
-  };
-}
-function build(config, callbacks, options) {
-  assertProjectCallbacks(config, callbacks);
-  assertProjectHooks(options?.hooks, callbacks);
-  if (!nativeCompilerFromConfig) {
-    throw new Error("createCompiler is not available in this binding");
-  }
-  const prepared = prepareCompilerConfig(config);
-  const compiler = nativeCompilerFromConfig(prepared, toNativeOptions(options), createUtilityValuesCallbacks(callbacks));
-  registerCallbacks(compiler, callbacks, options?.hooks, compiler.token_dictionary?.());
-  attachBuildInfo(compiler);
-  return compiler;
-}
-function attachBuildInfo(compiler) {
-  Object.defineProperty(compiler, "buildInfo", {
-    value: makeBuildInfoApi2(compiler),
-    enumerable: false
-  });
-}
-function toNativeOptions(options) {
-  if (!options || options.crossFile === void 0) return void 0;
-  return { crossFile: options.crossFile };
-}
-function createUtilityValuesCallbacks(callbacks) {
-  const utilityValues = callbacks["utility.values"];
-  if (!utilityValues || Object.keys(utilityValues).length === 0) return void 0;
-  return Object.fromEntries(
-    Object.entries(utilityValues).map(([id, callback]) => [
-      id,
-      (tokenDictionary) => callback((category) => getTokenCategoryValues(category, tokenDictionary))
-    ])
-  );
-}
-
-export {
-  createNodeDriver,
-  compile,
-  startTracing,
-  flushTracing,
-  shutdownTracing,
-  createCompiler,
-  createCompilerFromSnapshot,
-  getBindingInfo
-};