@pandacss/compiler-wasm 2.0.0-beta.0

package/dist/web.js

@@ -0,0 +1,107 @@
+// src/web.ts
+import {
+  assertProjectCallbacks,
+  assertProjectHooks,
+  getTokenCategoryValues,
+  makeBuildInfoApi,
+  mergeCallbacks,
+  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"];
+  if (utilityTransforms && Object.keys(utilityTransforms).length > 0 && !project.registerUtilityTransform) {
+    throw new Error("WASM project does not support utility.transform callbacks");
+  }
+  if (project.registerUtilityTransform && utilityTransforms && Object.keys(utilityTransforms).length > 0) {
+    for (const [id, callback] of Object.entries(utilityTransforms)) {
+      project.registerUtilityTransform(id, (resolved, original) => {
+        return callback(resolved, createTransformArgs(original, tokenDictionary));
+      });
+    }
+  }
+  const patternTransforms = callbacks["pattern.transform"];
+  if (patternTransforms && Object.keys(patternTransforms).length > 0 && !project.registerPatternTransform) {
+    throw new Error("WASM project does not support pattern.transform callbacks");
+  }
+  const config = project.config();
+  const patternDefaultValues = callbacks["pattern.defaultValues"];
+  const patternDefaultValueRefs = config && patternDefaultValues ? getPatternDefaultValueRefsByTransformId(config) : /* @__PURE__ */ new Map();
+  if (project.registerPatternTransform && patternTransforms && Object.keys(patternTransforms).length > 0) {
+    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());
+      });
+    }
+  }
+  const sourceTransforms = hooks?.["parser:before"];
+  if (sourceTransforms?.length && !project.registerSourceTransform) {
+    throw new Error("WASM 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/web.ts
+function createCompilerFromWasmModule(mod, config, options) {
+  return build(mod, config, options?.callbacks ?? {}, options?.hooks);
+}
+function build(mod, config, callbacks, hooks) {
+  const fs = new mod.WasmFileSystem();
+  assertProjectCallbacks(config, callbacks);
+  assertProjectHooks(hooks, callbacks);
+  const prepared = prepareCompilerConfig(config);
+  const compiler = mod.WasmCompiler.fromConfig(fs, prepared, buildFromConfigOptions(callbacks));
+  registerCallbacks(compiler, callbacks, hooks, compiler.token_dictionary?.());
+  compiler.fs = fs;
+  Object.defineProperty(compiler, "buildInfo", {
+    value: makeBuildInfoApi(compiler),
+    enumerable: false
+  });
+  return compiler;
+}
+function buildFromConfigOptions(callbacks) {
+  const utilityValues = callbacks["utility.values"];
+  if (!utilityValues || Object.keys(utilityValues).length === 0) return void 0;
+  return {
+    configCallbacks: {
+      utilityValues: Object.fromEntries(
+        Object.entries(utilityValues).map(([id, callback]) => [
+          id,
+          (tokenDictionary) => callback((category) => getTokenCategoryValues(category, tokenDictionary))
+        ])
+      )
+    }
+  };
+}
+export {
+  build,
+  buildFromConfigOptions,
+  createCompilerFromWasmModule,
+  mergeCallbacks
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@pandacss/compiler-wasm",
+  "version": "2.0.0-beta.0",
+  "description": "WebAssembly binding for the Panda compiler engine (browser/playground target)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./web": {
+      "source": "./src/web.ts",
+      "types": "./dist/web.d.ts",
+      "default": "./dist/web.js"
+    },
+    "./pkg-node/*": "./pkg-node/*",
+    "./pkg-web/*": "./pkg-web/*",
+    "./package.json": "./package.json"
+  },
+  "author": "Segun Adebayo <joseshegs@gmail.com>",
+  "license": "MIT",
+  "sideEffects": false,
+  "homepage": "https://panda-css.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chakra-ui/panda.git",
+    "directory": "packages/compiler-wasm"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "pkg-node",
+    "pkg-web"
+  ],
+  "dependencies": {
+    "@pandacss/compiler-shared": "2.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@pandacss/config": "2.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "pnpm build:wasm && pnpm build:js",
+    "build:js": "tsup",
+    "build:fast": "tsup --no-dts",
+    "build:wasm": "tsx build-wasm.ts",
+    "dev": "pnpm build:fast --watch",
+    "test": "vitest run"
+  }
+}

package/pkg-node/compiler_wasm.d.ts

@@ -0,0 +1,381 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * JS-facing project handle. Constructed once per session with a
+ * [`WasmFileSystem`] (whose contents the cross-file resolver reads),
+ * plus a resolved Panda config snapshot.
+ *
+ * ```js
+ * const fs = new WasmFileSystem()
+ * fs.addFile('/proj/tokens.ts', "export const brand = '#ef4444';")
+ * fs.addFile('/proj/main.tsx', "import { brand } from './tokens'\ncss({ color: brand })")
+ * const compiler = WasmCompiler.fromConfig(fs, config)
+ * project.parseFile('/proj/main.tsx', fs.readFile('/proj/main.tsx'))
+ * const atoms = project.atoms()
+ * ```
+ */
+export class WasmCompiler {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Hydrate an external build info into this project (additive), optionally
+     * restricted to imported modules (tree-shaking). Returns `false` on a
+     * schema-version mismatch.
+     *
+     * # Errors
+     * Returns a JS error if `build_info` isn't a valid build-info document.
+     */
+    applyBuildInfo(name: string, build_info: any, only: any): boolean;
+    /**
+     * Deduplicated atoms across every currently-known file, sorted by
+     * `(prop, conditions, value)` for stable iteration.
+     *
+     * # Errors
+     * Returns a JS error if serializing the atom array fails.
+     */
+    atoms(): any;
+    /**
+     * The build-info wire-format version this binding reads/writes.
+     */
+    buildInfoSchemaVersion(): number;
+    /**
+     * Drop every path's state. Keeps the config-derived extractor,
+     * token dictionary, and cross-file resolver intact.
+     */
+    clear(): void;
+    /**
+     * Compile to CSS. Mirrors the NAPI `Project.compile()`.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    compile(options?: any | null): any;
+    /**
+     * Return the serialized config snapshot this project was constructed
+     * with.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    config(): any;
+    /**
+     * Engine-owned fingerprint of the resolved config's output-affecting fields,
+     * stamped into build info as `configFingerprint`.
+     */
+    configFingerprint(): string;
+    /**
+     * Config validation diagnostics from construction.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    diagnostics(): any;
+    dirname(path: string): string;
+    /**
+     * Encoded config recipe styles, separate from atomic utility atoms.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    encodedRecipes(): any;
+    /**
+     * Stateless single-file extraction — raw `{ calls, jsx, diagnostics }`,
+     * using the project's configured matchers + token dictionary. Unlike
+     * `parseFile`, it registers nothing; it's the read-only peek companion.
+     *
+     * # Errors
+     * Returns a JS error string when serializing the result fails.
+     */
+    extractFileSource(path: string, source: string): any;
+    /**
+     * `(path, hex source_hash)` for every known file, sorted by path.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    fileManifest(): any;
+    /**
+     * Construct a compiler from the resolved, JSON-safe Panda config snapshot.
+     *
+     * # Errors
+     * Returns a JS error when `config` doesn't deserialize into JSON.
+     */
+    static fromConfig(fs: WasmFileSystem, config: any, options: any): WasmCompiler;
+    /**
+     * Generate artifacts affected by the provided config dependency names.
+     *
+     * # Errors
+     * Returns a JS error if dependencies/options are invalid or serializing fails.
+     */
+    generateAffectedArtifacts(dependencies: any, options: any): any;
+    /**
+     * Generate one codegen artifact by id.
+     *
+     * # Errors
+     * Returns a JS error if the id/options are invalid or serializing fails.
+     */
+    generateArtifact(id: string, options: any): any;
+    /**
+     * Generate every codegen artifact from the resolved project state.
+     *
+     * # Errors
+     * Returns a JS error if options are invalid or serializing fails.
+     */
+    generateArtifacts(options: any): any;
+    /**
+     * Per-file view; returns `null` when `path` isn't known.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    getFile(path: string): any;
+    /**
+     * Whether `css` declares Panda's cascade layers (`@layer reset, base, …;`),
+     * marking it as the stylesheet root to inject the compiled CSS into.
+     */
+    hasLayerDeclaration(css: string): boolean;
+    /**
+     * Stateless source inspection for tooling (reporting, lint, IDE). Returns
+     * classified Panda usage sites plus file-local extraction diagnostics.
+     *
+     * # Errors
+     * Returns a JS error if serialization fails.
+     */
+    inspectFileSource(path: string, source: string): any;
+    /**
+     * Returns `true` when the project has no files and no accumulated output.
+     */
+    isEmpty(): boolean;
+    /**
+     * Whether `path` is a source file the project extracts from — its
+     * `cwd`-relative form matches the configured `include`/`exclude` globs.
+     */
+    isSourceFile(path: string): boolean;
+    joinPath(parts: any): string;
+    /**
+     * CSS for the named cascade layers, concatenated in order. Sliced in Rust
+     * (byte offsets stay valid); unknown layer names are skipped.
+     */
+    layerCss(layers: string[]): string;
+    /**
+     * The resolved cascade-layer names (config overrides merged over defaults).
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    layers(): any;
+    /**
+     * Read a source file from the in-memory filesystem and parse it.
+     *
+     * # Errors
+     * Returns a JS error if serializing the per-call report fails.
+     */
+    parseFile(path: string): any;
+    /**
+     * Extract + encode provided source text. Replaces any prior contribution
+     * from `path`.
+     *
+     * # Errors
+     * Returns a JS error if serializing the per-call report fails.
+     */
+    parseFileSource(path: string, source: string): any;
+    /**
+     * Read + parse source paths returned from `scan()`. Returns one report per
+     * successfully parsed path.
+     *
+     * # Errors
+     * Returns a JS error when `paths` is malformed or serializing the report fails.
+     */
+    parseFiles(paths: any): any;
+    /**
+     * Real on-disk path (symlinks followed) from the in-memory filesystem, so two
+     * paths to the same file compare equal. Returns the input when unresolved.
+     */
+    realpath(path: string): string;
+    /**
+     * Every `cva()` recipe entry in `(file, span_start)` order.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    recipes(): any;
+    /**
+     * Re-read `path` from the in-memory filesystem and re-parse it only if
+     * already known. Returns `true` when the file was present and got
+     * re-parsed.
+     */
+    refreshFile(path: string): boolean;
+    /**
+     * Re-parse provided source text only if `path` is already known.
+     */
+    refreshFileSource(path: string, source: string): boolean;
+    /**
+     * Register a JS-backed pattern transform callback. The wrapper package
+     * installs callbacks referenced by the serialized config snapshot.
+     */
+    registerPatternTransform(id: string, callback: Function): void;
+    /**
+     * Register a JS-backed `parser:before` source transform with a Rust-side
+     * filter. The filter is evaluated before calling into JS.
+     */
+    registerSourceTransform(id: string, filter: any, callback: Function): void;
+    /**
+     * Register a JS-backed utility transform callback. The JS package wraps
+     * the user callback so Rust only has to pass the raw value.
+     */
+    registerUtilityTransform(id: string, callback: Function): void;
+    /**
+     * Drop a file's contribution. Returns `true` if the path was known.
+     */
+    removeFile(path: string): boolean;
+    resolvePath(path: string, cwd?: string | null): string;
+    /**
+     * Source paths matching the config's `include`/`exclude` (overridable via
+     * `options`) from the in-memory filesystem. For discovery and the host's
+     * watch list.
+     *
+     * # Errors
+     * Returns a JS error when `options` is malformed or the scan fails.
+     */
+    scan(options: any): any;
+    /**
+     * Serialize the project's encoded atoms + recipes into a portable build info
+     * (the `panda buildinfo` producer). `configFingerprint` is engine-owned; the
+     * caller supplies only the published `panda` peer range.
+     *
+     * # Errors
+     * Returns a JS error if serializing the build info fails.
+     */
+    serializeBuildInfo(panda: string): any;
+    /**
+     * Every `sva()` slot-recipe entry.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    slotRecipes(): any;
+    /**
+     * Source globs + their static base dirs (for the host watcher).
+     *
+     * # Errors
+     * Returns a JS error if serialization fails.
+     */
+    sources(): any;
+    /**
+     * Tooling introspection snapshot (read once, index on the host).
+     *
+     * # Errors
+     * Returns a JS error if the snapshot fails to serialize.
+     */
+    spec(): any;
+    /**
+     * Split the stylesheet into per-file outputs (one per layer + per recipe,
+     * plus `recipes.css` / `styles.css` index files) for `--splitting`.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    splitCss(): any;
+    /**
+     * `staticCss.patterns` expansion as raw atoms, without compiling.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    staticPatternAtoms(): any;
+    /**
+     * Aggregate counts.
+     *
+     * # Errors
+     * Returns a JS error if serializing fails.
+     */
+    summary(): any;
+    /**
+     * Rust-built token dictionary projected into the small JS interop shape.
+     */
+    token_dictionary(): any;
+    /**
+     * Generate artifacts and write them under `outdir` via the in-memory fs.
+     * Returns the written paths.
+     *
+     * # Errors
+     * Returns a JS error if a file fails to write or results fail to serialize.
+     */
+    writeArtifacts(outdir: string, cwd: string | null | undefined, options: any): any;
+    writeCss(outfile: string, cwd?: string | null, options?: any | null): any;
+    writeSplitCss(outdir: string, cwd?: string | null): any;
+}
+
+/**
+ * JS-facing extractor handle. Constructed once per session with a
+ * [`WasmFileSystem`] handle and a `MatchersInput`; the cross-file
+ * resolver is wired up automatically against the same FS.
+ *
+ * ```js
+ * const fs = new WasmFileSystem();
+ * fs.addFile('/src/code.tsx', '...');
+ * const ext = new WasmExtractor(fs, matchers);
+ * const result = ext.parseFile('/src/code.tsx', source);
+ * ```
+ */
+export class WasmExtractor {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Construct from a JS matchers object (see `MatchersInput`).
+     *
+     * # Errors
+     * Returns a JS error string when `matchers` doesn't deserialize
+     * into a `MatchersInput` shape.
+     */
+    constructor(fs: WasmFileSystem, matchers: any);
+    /**
+     * Single-file extract. Returns the lean `ExtractUsage` shape as a
+     * plain JS object (`{ calls, jsx, diagnostics }`).
+     *
+     * # Errors
+     * Returns a JS error string when serializing the result to `JsValue`
+     * fails (effectively never — the shape is bounded JSON).
+     */
+    parseFile(path: string, source: string): any;
+}
+
+/**
+ * JS-facing handle over [`MemoryFileSystem`]. Cheap to clone — shares
+ * state via `Arc<RwLock>` internally — so the JS host can pass the same
+ * handle into multiple `WasmExtractor` instances and edits flow through
+ * to all consumers.
+ */
+export class WasmFileSystem {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Write or overwrite a file. Parent dirs auto-register.
+     */
+    addFile(path: string, content: string): void;
+    /**
+     * `true` when `path` exists as file or directory.
+     */
+    exists(path: string): boolean;
+    /**
+     * Number of files stored. Convenience for diagnostics / tests.
+     */
+    fileCount(): number;
+    constructor();
+    /**
+     * Read a file. Returns `undefined` when missing.
+     */
+    readFile(path: string): string | undefined;
+    /**
+     * `true` when the file existed and was removed.
+     */
+    removeFile(path: string): boolean;
+}
+
+/**
+ * Install a panic hook so Rust panics surface as readable stack traces in
+ * the browser console. Idempotent — safe to call multiple times.
+ */
+export function installPanicHook(): void;