@pandacss/typescript-plugin 2.0.0-beta.9

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-IR4B4RGW.js

@@ -0,0 +1,207 @@
+// src/service/ast.ts
+import ts from "typescript";
+function findNodeAtPosition(root, position) {
+  let found = root;
+  const visit = (node) => {
+    if (position < node.getStart() || position > node.getEnd()) return;
+    found = node;
+    node.forEachChild(visit);
+  };
+  visit(root);
+  return found;
+}
+function findEnclosingStringLiteral(root, position) {
+  const node = findNodeAtPosition(root, position);
+  return ts.isStringLiteralLike(node) ? node : void 0;
+}
+function findEnclosingObjectLiteral(node) {
+  let current = node;
+  while (current) {
+    if (ts.isObjectLiteralExpression(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function propertyKeyText(name) {
+  return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : void 0;
+}
+function getContainerPath(node) {
+  const path = [];
+  let current = node;
+  while (current) {
+    if (ts.isPropertyAssignment(current)) {
+      const key = propertyKeyText(current.name);
+      if (key !== void 0) path.unshift(key);
+    }
+    current = current.parent;
+  }
+  return path[0] === "theme" ? path.slice(1) : path;
+}
+var RECIPE_DEFINE_NAMES = /* @__PURE__ */ new Set(["defineRecipe"]);
+var GLOBAL_STYLES_DEFINE_NAMES = /* @__PURE__ */ new Set(["defineGlobalStyles"]);
+function calleeName(call) {
+  return ts.isIdentifier(call.expression) ? call.expression.text : void 0;
+}
+function findEnclosingDefineCall(node) {
+  let current = node;
+  while (current) {
+    if (ts.isCallExpression(current)) {
+      const name = calleeName(current);
+      const [firstArg] = current.arguments;
+      if (name && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+        if (RECIPE_DEFINE_NAMES.has(name)) return { kind: "recipe", argument: firstArg };
+        if (GLOBAL_STYLES_DEFINE_NAMES.has(name)) return { kind: "global-styles", argument: firstArg };
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function getLocalPath(root, target) {
+  const path = [];
+  let current = target;
+  while (current !== root) {
+    const parent = current.parent;
+    if (ts.isPropertyAssignment(parent) && parent.initializer === current) {
+      const key = propertyKeyText(parent.name);
+      if (key !== void 0) path.unshift(key);
+    }
+    current = parent;
+  }
+  return path;
+}
+function toStyleObjectPath(kind, fullPath) {
+  if (kind === "global-styles") return fullPath.length >= 1 ? fullPath.slice(1) : void 0;
+  if (fullPath[0] === "base") return fullPath.slice(1);
+  if (fullPath[0] === "variants" && fullPath.length >= 3) return fullPath.slice(3);
+  return void 0;
+}
+function getStyleObjectCursorInfo(sourceFile, position) {
+  const node = findNodeAtPosition(sourceFile, position);
+  const defineCall = findEnclosingDefineCall(node);
+  if (!defineCall) return void 0;
+  if (ts.isStringLiteralLike(node)) {
+    const fullPath2 = getLocalPath(defineCall.argument, node);
+    const propertyPath2 = toStyleObjectPath(defineCall.kind, fullPath2);
+    if (!propertyPath2 || propertyPath2.length === 0) return void 0;
+    return { existingKeys: [], cursorKind: "value", propertyPath: propertyPath2 };
+  }
+  const objectLiteral = findEnclosingObjectLiteral(node);
+  if (!objectLiteral) return void 0;
+  const fullPath = getLocalPath(defineCall.argument, objectLiteral);
+  const propertyPath = toStyleObjectPath(defineCall.kind, fullPath);
+  if (!propertyPath) return void 0;
+  const existingKeys = objectLiteral.properties.filter(ts.isPropertyAssignment).map((property) => propertyKeyText(property.name)).filter((key) => key !== void 0);
+  return { existingKeys, cursorKind: "key", propertyPath };
+}
+var SEMANTIC_TOKENS_NAME = "defineSemanticTokens";
+function findEnclosingSemanticTokensCall(node) {
+  let current = node;
+  while (current) {
+    if (ts.isCallExpression(current)) {
+      const [firstArg] = current.arguments;
+      if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+        const callee = current.expression;
+        if (ts.isIdentifier(callee) && callee.text === SEMANTIC_TOKENS_NAME) {
+          return { argument: firstArg };
+        }
+        if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === SEMANTIC_TOKENS_NAME && ts.isIdentifier(callee.name)) {
+          return { argument: firstArg, category: callee.name.text };
+        }
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function isTokenValueObject(objectLiteral) {
+  let current = objectLiteral;
+  while (true) {
+    const parent = current.parent;
+    if (!ts.isPropertyAssignment(parent) || parent.initializer !== current) return false;
+    if (propertyKeyText(parent.name) === "value") return true;
+    current = parent.parent;
+    if (!ts.isObjectLiteralExpression(current)) return false;
+  }
+}
+function getSemanticTokenCursorInfo(sourceFile, position) {
+  const node = findNodeAtPosition(sourceFile, position);
+  const objectLiteral = findEnclosingObjectLiteral(node);
+  if (!objectLiteral) return void 0;
+  const call = findEnclosingSemanticTokensCall(objectLiteral);
+  if (!call) return void 0;
+  const existingKeys = objectLiteral.properties.filter(ts.isPropertyAssignment).map((property) => propertyKeyText(property.name)).filter((key) => key !== void 0);
+  if (objectLiteral === call.argument && !call.category) {
+    return { cursorKind: "category", existingKeys };
+  }
+  if (isTokenValueObject(objectLiteral)) {
+    return { cursorKind: "condition", existingKeys };
+  }
+  return void 0;
+}
+
+// src/service/language-service.ts
+import ts2 from "typescript";
+import {
+  completeConfigStyleObject,
+  completeConfigTokenPath,
+  completeSemanticTokenObject,
+  findConfigTokenRefAt,
+  resolveModuleTarget
+} from "@pandacss/compiler/tooling";
+function literalContentStart(literal) {
+  return literal.getStart() + 1;
+}
+function getCompletions(query, context) {
+  const sourceFile = query.sourceFile ?? ts2.createSourceFile(query.fileName, query.source, ts2.ScriptTarget.Latest, true);
+  const literal = findEnclosingStringLiteral(sourceFile, query.position);
+  if (literal) {
+    const contentStart = literalContentStart(literal);
+    const textPosition = query.position - contentStart;
+    const tokenRef = findConfigTokenRefAt(literal.text, textPosition);
+    if (tokenRef && textPosition >= tokenRef.pathStart && textPosition <= tokenRef.pathEnd) {
+      const prefix2 = literal.text.slice(tokenRef.pathStart, textPosition);
+      return completeConfigTokenPath(prefix2, context.specIndex).map((name) => ({ name, kind: "token" }));
+    }
+  }
+  const prefix = literal ? query.source.slice(literalContentStart(literal), query.position) : "";
+  const cursorInfo = getStyleObjectCursorInfo(sourceFile, query.position);
+  if (cursorInfo) {
+    return completeConfigStyleObject({ ...cursorInfo, prefix }, context.specIndex);
+  }
+  const semanticTokenCursorInfo = getSemanticTokenCursorInfo(sourceFile, query.position);
+  if (semanticTokenCursorInfo) {
+    return completeSemanticTokenObject({ ...semanticTokenCursorInfo, prefix }, context.specIndex);
+  }
+  return [];
+}
+function getHover(query, context) {
+  const sourceFile = query.sourceFile ?? ts2.createSourceFile(query.fileName, query.source, ts2.ScriptTarget.Latest, true);
+  const literal = findEnclosingStringLiteral(sourceFile, query.position);
+  if (!literal) return null;
+  const contentStart = literalContentStart(literal);
+  const tokenRef = findConfigTokenRefAt(literal.text, query.position - contentStart);
+  if (!tokenRef) return null;
+  const value = context.specIndex.resolveTokenValue(tokenRef.path);
+  if (value === void 0) return null;
+  return {
+    text: `${tokenRef.path}
+${value}`,
+    start: contentStart + tokenRef.start,
+    end: contentStart + tokenRef.end
+  };
+}
+function resolveModule(specifier, context) {
+  return resolveModuleTarget(specifier, context.importMap, { outdir: context.outdir });
+}
+
+export {
+  findNodeAtPosition,
+  findEnclosingStringLiteral,
+  getContainerPath,
+  findEnclosingDefineCall,
+  getStyleObjectCursorInfo,
+  getCompletions,
+  getHover,
+  resolveModule
+};

package/dist/index.cjs

@@ -0,0 +1,305 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createPluginModuleFactory: () => createPluginModuleFactory,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin/index.ts
+var import_typescript3 = __toESM(require("typescript"), 1);
+var import_tooling2 = require("@pandacss/compiler/tooling");
+
+// src/service/language-service.ts
+var import_typescript2 = __toESM(require("typescript"), 1);
+var import_tooling = require("@pandacss/compiler/tooling");
+
+// src/service/ast.ts
+var import_typescript = __toESM(require("typescript"), 1);
+function findNodeAtPosition(root, position) {
+  let found = root;
+  const visit = (node) => {
+    if (position < node.getStart() || position > node.getEnd()) return;
+    found = node;
+    node.forEachChild(visit);
+  };
+  visit(root);
+  return found;
+}
+function findEnclosingStringLiteral(root, position) {
+  const node = findNodeAtPosition(root, position);
+  return import_typescript.default.isStringLiteralLike(node) ? node : void 0;
+}
+function findEnclosingObjectLiteral(node) {
+  let current = node;
+  while (current) {
+    if (import_typescript.default.isObjectLiteralExpression(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function propertyKeyText(name) {
+  return import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) ? name.text : void 0;
+}
+var RECIPE_DEFINE_NAMES = /* @__PURE__ */ new Set(["defineRecipe"]);
+var GLOBAL_STYLES_DEFINE_NAMES = /* @__PURE__ */ new Set(["defineGlobalStyles"]);
+function calleeName(call) {
+  return import_typescript.default.isIdentifier(call.expression) ? call.expression.text : void 0;
+}
+function findEnclosingDefineCall(node) {
+  let current = node;
+  while (current) {
+    if (import_typescript.default.isCallExpression(current)) {
+      const name = calleeName(current);
+      const [firstArg] = current.arguments;
+      if (name && firstArg && import_typescript.default.isObjectLiteralExpression(firstArg)) {
+        if (RECIPE_DEFINE_NAMES.has(name)) return { kind: "recipe", argument: firstArg };
+        if (GLOBAL_STYLES_DEFINE_NAMES.has(name)) return { kind: "global-styles", argument: firstArg };
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function getLocalPath(root, target) {
+  const path = [];
+  let current = target;
+  while (current !== root) {
+    const parent = current.parent;
+    if (import_typescript.default.isPropertyAssignment(parent) && parent.initializer === current) {
+      const key = propertyKeyText(parent.name);
+      if (key !== void 0) path.unshift(key);
+    }
+    current = parent;
+  }
+  return path;
+}
+function toStyleObjectPath(kind, fullPath) {
+  if (kind === "global-styles") return fullPath.length >= 1 ? fullPath.slice(1) : void 0;
+  if (fullPath[0] === "base") return fullPath.slice(1);
+  if (fullPath[0] === "variants" && fullPath.length >= 3) return fullPath.slice(3);
+  return void 0;
+}
+function getStyleObjectCursorInfo(sourceFile, position) {
+  const node = findNodeAtPosition(sourceFile, position);
+  const defineCall = findEnclosingDefineCall(node);
+  if (!defineCall) return void 0;
+  if (import_typescript.default.isStringLiteralLike(node)) {
+    const fullPath2 = getLocalPath(defineCall.argument, node);
+    const propertyPath2 = toStyleObjectPath(defineCall.kind, fullPath2);
+    if (!propertyPath2 || propertyPath2.length === 0) return void 0;
+    return { existingKeys: [], cursorKind: "value", propertyPath: propertyPath2 };
+  }
+  const objectLiteral = findEnclosingObjectLiteral(node);
+  if (!objectLiteral) return void 0;
+  const fullPath = getLocalPath(defineCall.argument, objectLiteral);
+  const propertyPath = toStyleObjectPath(defineCall.kind, fullPath);
+  if (!propertyPath) return void 0;
+  const existingKeys = objectLiteral.properties.filter(import_typescript.default.isPropertyAssignment).map((property) => propertyKeyText(property.name)).filter((key) => key !== void 0);
+  return { existingKeys, cursorKind: "key", propertyPath };
+}
+var SEMANTIC_TOKENS_NAME = "defineSemanticTokens";
+function findEnclosingSemanticTokensCall(node) {
+  let current = node;
+  while (current) {
+    if (import_typescript.default.isCallExpression(current)) {
+      const [firstArg] = current.arguments;
+      if (firstArg && import_typescript.default.isObjectLiteralExpression(firstArg)) {
+        const callee = current.expression;
+        if (import_typescript.default.isIdentifier(callee) && callee.text === SEMANTIC_TOKENS_NAME) {
+          return { argument: firstArg };
+        }
+        if (import_typescript.default.isPropertyAccessExpression(callee) && import_typescript.default.isIdentifier(callee.expression) && callee.expression.text === SEMANTIC_TOKENS_NAME && import_typescript.default.isIdentifier(callee.name)) {
+          return { argument: firstArg, category: callee.name.text };
+        }
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function isTokenValueObject(objectLiteral) {
+  let current = objectLiteral;
+  while (true) {
+    const parent = current.parent;
+    if (!import_typescript.default.isPropertyAssignment(parent) || parent.initializer !== current) return false;
+    if (propertyKeyText(parent.name) === "value") return true;
+    current = parent.parent;
+    if (!import_typescript.default.isObjectLiteralExpression(current)) return false;
+  }
+}
+function getSemanticTokenCursorInfo(sourceFile, position) {
+  const node = findNodeAtPosition(sourceFile, position);
+  const objectLiteral = findEnclosingObjectLiteral(node);
+  if (!objectLiteral) return void 0;
+  const call = findEnclosingSemanticTokensCall(objectLiteral);
+  if (!call) return void 0;
+  const existingKeys = objectLiteral.properties.filter(import_typescript.default.isPropertyAssignment).map((property) => propertyKeyText(property.name)).filter((key) => key !== void 0);
+  if (objectLiteral === call.argument && !call.category) {
+    return { cursorKind: "category", existingKeys };
+  }
+  if (isTokenValueObject(objectLiteral)) {
+    return { cursorKind: "condition", existingKeys };
+  }
+  return void 0;
+}
+
+// src/service/language-service.ts
+function literalContentStart(literal) {
+  return literal.getStart() + 1;
+}
+function getCompletions(query, context) {
+  const sourceFile = query.sourceFile ?? import_typescript2.default.createSourceFile(query.fileName, query.source, import_typescript2.default.ScriptTarget.Latest, true);
+  const literal = findEnclosingStringLiteral(sourceFile, query.position);
+  if (literal) {
+    const contentStart = literalContentStart(literal);
+    const textPosition = query.position - contentStart;
+    const tokenRef = (0, import_tooling.findConfigTokenRefAt)(literal.text, textPosition);
+    if (tokenRef && textPosition >= tokenRef.pathStart && textPosition <= tokenRef.pathEnd) {
+      const prefix2 = literal.text.slice(tokenRef.pathStart, textPosition);
+      return (0, import_tooling.completeConfigTokenPath)(prefix2, context.specIndex).map((name) => ({ name, kind: "token" }));
+    }
+  }
+  const prefix = literal ? query.source.slice(literalContentStart(literal), query.position) : "";
+  const cursorInfo = getStyleObjectCursorInfo(sourceFile, query.position);
+  if (cursorInfo) {
+    return (0, import_tooling.completeConfigStyleObject)({ ...cursorInfo, prefix }, context.specIndex);
+  }
+  const semanticTokenCursorInfo = getSemanticTokenCursorInfo(sourceFile, query.position);
+  if (semanticTokenCursorInfo) {
+    return (0, import_tooling.completeSemanticTokenObject)({ ...semanticTokenCursorInfo, prefix }, context.specIndex);
+  }
+  return [];
+}
+function getHover(query, context) {
+  const sourceFile = query.sourceFile ?? import_typescript2.default.createSourceFile(query.fileName, query.source, import_typescript2.default.ScriptTarget.Latest, true);
+  const literal = findEnclosingStringLiteral(sourceFile, query.position);
+  if (!literal) return null;
+  const contentStart = literalContentStart(literal);
+  const tokenRef = (0, import_tooling.findConfigTokenRefAt)(literal.text, query.position - contentStart);
+  if (!tokenRef) return null;
+  const value = context.specIndex.resolveTokenValue(tokenRef.path);
+  if (value === void 0) return null;
+  return {
+    text: `${tokenRef.path}
+${value}`,
+    start: contentStart + tokenRef.start,
+    end: contentStart + tokenRef.end
+  };
+}
+
+// src/plugin/index.ts
+var EMPTY_IMPORT_MAP = { css: [], recipe: [], pattern: [], jsx: [], tokens: [] };
+var defaultRegistry = new import_tooling2.ProjectRegistry();
+var defaultLoadProject = (key) => defaultRegistry.getProject(key);
+function readScriptText(host, fileName) {
+  const snapshot = host.getScriptSnapshot(fileName);
+  return snapshot?.getText(0, snapshot.getLength());
+}
+function readDocument(languageService, host, fileName) {
+  const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+  if (sourceFile) return { source: sourceFile.text, sourceFile };
+  const source = readScriptText(host, fileName);
+  return source === void 0 ? void 0 : { source };
+}
+function mergeCompletions(prior, entries) {
+  const pandaEntries = entries.map((entry) => ({
+    name: entry.name,
+    kind: import_typescript3.default.ScriptElementKind.string,
+    kindModifiers: "",
+    sortText: "0",
+    source: "panda-css"
+  }));
+  if (!prior) {
+    return {
+      isGlobalCompletion: false,
+      isMemberCompletion: false,
+      isNewIdentifierLocation: false,
+      entries: pandaEntries
+    };
+  }
+  return { ...prior, entries: [...pandaEntries, ...prior.entries] };
+}
+function createPluginModuleFactory(loadProject = defaultLoadProject) {
+  return () => {
+    function create(info) {
+      const proxy = /* @__PURE__ */ Object.create(null);
+      for (const key of Object.keys(info.languageService)) {
+        const original = info.languageService[key];
+        proxy[key] = (...args) => original.apply(info.languageService, args);
+      }
+      let context;
+      const refresh = () => {
+        loadProject({ cwd: info.project.getCurrentDirectory() }).then((project) => {
+          context = {
+            specIndex: new import_tooling2.SpecIndex(project.compiler.spec()),
+            importMap: project.compiler.spec().importMap ?? EMPTY_IMPORT_MAP,
+            outdir: project.outdir
+          };
+        }).catch(() => void 0);
+      };
+      refresh();
+      proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+        refresh();
+        const prior = info.languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+        if (!context) return prior;
+        const doc = readDocument(info.languageService, info.languageServiceHost, fileName);
+        if (!doc) return prior;
+        const entries = getCompletions({ fileName, position, ...doc }, context);
+        return entries.length === 0 ? prior : mergeCompletions(prior, entries);
+      };
+      proxy.getQuickInfoAtPosition = (fileName, position) => {
+        refresh();
+        const prior = info.languageService.getQuickInfoAtPosition(fileName, position);
+        if (!context) return prior;
+        const doc = readDocument(info.languageService, info.languageServiceHost, fileName);
+        if (!doc) return prior;
+        const hover = getHover({ fileName, position, ...doc }, context);
+        if (!hover) return prior;
+        return {
+          kind: import_typescript3.default.ScriptElementKind.string,
+          kindModifiers: "",
+          textSpan: { start: hover.start, length: hover.end - hover.start },
+          displayParts: [{ text: hover.text, kind: "text" }]
+        };
+      };
+      return proxy;
+    }
+    return { create };
+  };
+}
+var factory = createPluginModuleFactory();
+var plugin_default = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPluginModuleFactory
+});

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+import { Project } from '@pandacss/compiler/tooling';
+
+type ProjectLoader = (key: {
+    cwd: string;
+}) => Promise<Project>;
+declare function createPluginModuleFactory(loadProject?: ProjectLoader): ts.server.PluginModuleFactory;
+declare const factory: ts.server.PluginModuleFactory;
+
+export { type ProjectLoader, createPluginModuleFactory, factory as default };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+import { Project } from '@pandacss/compiler/tooling';
+
+type ProjectLoader = (key: {
+    cwd: string;
+}) => Promise<Project>;
+declare function createPluginModuleFactory(loadProject?: ProjectLoader): ts.server.PluginModuleFactory;
+declare const factory: ts.server.PluginModuleFactory;
+
+export { type ProjectLoader, createPluginModuleFactory, factory as default };

package/dist/index.js

@@ -0,0 +1,93 @@
+import {
+  getCompletions,
+  getHover
+} from "./chunk-IR4B4RGW.js";
+
+// src/plugin/index.ts
+import ts from "typescript";
+import { ProjectRegistry, SpecIndex } from "@pandacss/compiler/tooling";
+var EMPTY_IMPORT_MAP = { css: [], recipe: [], pattern: [], jsx: [], tokens: [] };
+var defaultRegistry = new ProjectRegistry();
+var defaultLoadProject = (key) => defaultRegistry.getProject(key);
+function readScriptText(host, fileName) {
+  const snapshot = host.getScriptSnapshot(fileName);
+  return snapshot?.getText(0, snapshot.getLength());
+}
+function readDocument(languageService, host, fileName) {
+  const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+  if (sourceFile) return { source: sourceFile.text, sourceFile };
+  const source = readScriptText(host, fileName);
+  return source === void 0 ? void 0 : { source };
+}
+function mergeCompletions(prior, entries) {
+  const pandaEntries = entries.map((entry) => ({
+    name: entry.name,
+    kind: ts.ScriptElementKind.string,
+    kindModifiers: "",
+    sortText: "0",
+    source: "panda-css"
+  }));
+  if (!prior) {
+    return {
+      isGlobalCompletion: false,
+      isMemberCompletion: false,
+      isNewIdentifierLocation: false,
+      entries: pandaEntries
+    };
+  }
+  return { ...prior, entries: [...pandaEntries, ...prior.entries] };
+}
+function createPluginModuleFactory(loadProject = defaultLoadProject) {
+  return () => {
+    function create(info) {
+      const proxy = /* @__PURE__ */ Object.create(null);
+      for (const key of Object.keys(info.languageService)) {
+        const original = info.languageService[key];
+        proxy[key] = (...args) => original.apply(info.languageService, args);
+      }
+      let context;
+      const refresh = () => {
+        loadProject({ cwd: info.project.getCurrentDirectory() }).then((project) => {
+          context = {
+            specIndex: new SpecIndex(project.compiler.spec()),
+            importMap: project.compiler.spec().importMap ?? EMPTY_IMPORT_MAP,
+            outdir: project.outdir
+          };
+        }).catch(() => void 0);
+      };
+      refresh();
+      proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+        refresh();
+        const prior = info.languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
+        if (!context) return prior;
+        const doc = readDocument(info.languageService, info.languageServiceHost, fileName);
+        if (!doc) return prior;
+        const entries = getCompletions({ fileName, position, ...doc }, context);
+        return entries.length === 0 ? prior : mergeCompletions(prior, entries);
+      };
+      proxy.getQuickInfoAtPosition = (fileName, position) => {
+        refresh();
+        const prior = info.languageService.getQuickInfoAtPosition(fileName, position);
+        if (!context) return prior;
+        const doc = readDocument(info.languageService, info.languageServiceHost, fileName);
+        if (!doc) return prior;
+        const hover = getHover({ fileName, position, ...doc }, context);
+        if (!hover) return prior;
+        return {
+          kind: ts.ScriptElementKind.string,
+          kindModifiers: "",
+          textSpan: { start: hover.start, length: hover.end - hover.start },
+          displayParts: [{ text: hover.text, kind: "text" }]
+        };
+      };
+      return proxy;
+    }
+    return { create };
+  };
+}
+var factory = createPluginModuleFactory();
+var plugin_default = factory;
+export {
+  createPluginModuleFactory,
+  plugin_default as default
+};

package/dist/service/index.d.ts

@@ -0,0 +1,52 @@
+import ts from 'typescript';
+import { ImportMapOutput } from '@pandacss/compiler-shared';
+import { SpecIndex, CompletionEntry } from '@pandacss/compiler/tooling';
+
+declare function findNodeAtPosition(root: ts.Node, position: number): ts.Node;
+declare function findEnclosingStringLiteral(root: ts.Node, position: number): ts.StringLiteralLike | undefined;
+declare function getContainerPath(node: ts.Node): string[];
+type StyleObjectDefineKind = 'recipe' | 'global-styles';
+interface DefineCallMatch {
+    kind: StyleObjectDefineKind;
+    argument: ts.ObjectLiteralExpression;
+}
+declare function findEnclosingDefineCall(node: ts.Node): DefineCallMatch | undefined;
+interface StyleObjectCursorInfo {
+    existingKeys: string[];
+    cursorKind: 'key' | 'value';
+    /**
+     * Style-object-relative key chain leading to the cursor — e.g. `['color']` for a plain
+     * `color: 're'`, or `['backgroundColor', 'sm']` for `backgroundColor: { sm: 're' }` (a
+     * utility's own inline conditional value, which can nest to any depth:
+     * `ConditionalValue<V> = V | Array<V> | { [condition]?: ConditionalValue<V> }`). This layer
+     * has no spec access, so it can't tell a condition key (nested style object) from a utility
+     * key (its own conditional-value wrapper) apart — the completion layer, which does have the
+     * spec, resolves the first segment that's a real utility and treats everything after it as
+     * condition keys wrapping that same property's value.
+     */
+    propertyPath: string[];
+}
+declare function getStyleObjectCursorInfo(sourceFile: ts.SourceFile, position: number): StyleObjectCursorInfo | undefined;
+
+interface DocumentQuery {
+    fileName: string;
+    source: string;
+    position: number;
+    /** Reuse an already-parsed AST (e.g. tsserver's own Program) instead of re-parsing `source`. */
+    sourceFile?: ts.SourceFile;
+}
+interface LanguageServiceContext {
+    specIndex: SpecIndex;
+    importMap: ImportMapOutput;
+    outdir: string;
+}
+interface HoverInfo {
+    text: string;
+    start: number;
+    end: number;
+}
+declare function getCompletions(query: DocumentQuery, context: LanguageServiceContext): CompletionEntry[];
+declare function getHover(query: DocumentQuery, context: LanguageServiceContext): HoverInfo | null;
+declare function resolveModule(specifier: string, context: LanguageServiceContext): string | undefined;
+
+export { type DefineCallMatch, type DocumentQuery, type HoverInfo, type LanguageServiceContext, type StyleObjectCursorInfo, type StyleObjectDefineKind, findEnclosingDefineCall, findEnclosingStringLiteral, findNodeAtPosition, getCompletions, getContainerPath, getHover, getStyleObjectCursorInfo, resolveModule };

package/dist/service/index.js

@@ -0,0 +1,20 @@
+import {
+  findEnclosingDefineCall,
+  findEnclosingStringLiteral,
+  findNodeAtPosition,
+  getCompletions,
+  getContainerPath,
+  getHover,
+  getStyleObjectCursorInfo,
+  resolveModule
+} from "../chunk-IR4B4RGW.js";
+export {
+  findEnclosingDefineCall,
+  findEnclosingStringLiteral,
+  findNodeAtPosition,
+  getCompletions,
+  getContainerPath,
+  getHover,
+  getStyleObjectCursorInfo,
+  resolveModule
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@pandacss/typescript-plugin",
+  "version": "2.0.0-beta.9",
+  "description": "TypeScript language service plugin for Panda CSS config authoring",
+  "keywords": [
+    "typescript-plugin",
+    "tsserver",
+    "panda",
+    "pandacss",
+    "css-in-js"
+  ],
+  "type": "module",
+  "main": "./plugin.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "require": "./plugin.cjs",
+      "default": "./dist/index.js"
+    },
+    "./service": {
+      "source": "./src/service/index.ts",
+      "types": "./dist/service/index.d.ts",
+      "default": "./dist/service/index.js"
+    },
+    "./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/typescript-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "plugin.cjs"
+  ],
+  "dependencies": {
+    "@pandacss/compiler": "2.0.0-beta.9",
+    "@pandacss/compiler-shared": "2.0.0-beta.9"
+  },
+  "devDependencies": {
+    "typescript": "6.0.2",
+    "@pandacss/dev": "2.0.0-beta.9"
+  },
+  "peerDependencies": {
+    "typescript": ">=5"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsup --dts",
+    "build:fast": "tsup --no-dts",
+    "dev": "pnpm build:fast --watch",
+    "test": "vitest run"
+  }
+}

package/plugin.cjs

@@ -0,0 +1,7 @@
+// Static, hand-written — not built by tsup. tsserver's plugin loader does a plain
+// CommonJS `require()` and needs `module.exports` to literally be the callable
+// factory. The compiled `dist/index.cjs` exports `{ default: factory, ... }` (esbuild's
+// ESM-to-CJS interop shape), which real tsserver could not call directly — confirmed
+// via a real tsserver process logging "did not expose a proper factory function"
+// before this shim existed. This unwraps it.
+module.exports = require('./dist/index.cjs').default