semicons 0.0.1

package/dist/extension.js

@@ -0,0 +1,827 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extension.ts
+var extension_exports = {};
+__export(extension_exports, {
+  activate: () => activate,
+  deactivate: () => deactivate
+});
+module.exports = __toCommonJS(extension_exports);
+var import_vscode12 = require("vscode");
+
+// src/registry/watcher.ts
+var import_vscode3 = require("vscode");
+
+// src/registry/cache.ts
+var import_vscode2 = require("vscode");
+
+// src/registry/loader.ts
+var import_vscode = require("vscode");
+async function loadRegistry(folderUri) {
+  const config = import_vscode.workspace.getConfiguration("semicons", folderUri);
+  const registryPath = config.get("registryPath", "src/icons.generated/registry.json");
+  const registryUri = import_vscode.Uri.joinPath(folderUri, registryPath);
+  try {
+    const document = await import_vscode.workspace.openTextDocument(registryUri);
+    const content = document.getText();
+    const registry = JSON.parse(content);
+    return registry;
+  } catch (error) {
+    return null;
+  }
+}
+function resolveRegistryPath(folderUri) {
+  const config = import_vscode.workspace.getConfiguration("semicons", folderUri);
+  const registryPath = config.get("registryPath", "src/icons.generated/registry.json");
+  return import_vscode.Uri.joinPath(folderUri, registryPath);
+}
+
+// src/registry/cache.ts
+var cache = {};
+async function getRegistryForFile(fileUri) {
+  const folder = import_vscode2.workspace.getWorkspaceFolder(fileUri);
+  if (folder) {
+    const folderKey = folder.uri.toString();
+    if (!cache[folderKey]) {
+      cache[folderKey] = await loadRegistry(folder.uri);
+    }
+    return cache[folderKey];
+  }
+  const folders = import_vscode2.workspace.workspaceFolders;
+  if (folders && folders.length > 0) {
+    const firstFolder = folders[0];
+    const firstKey = firstFolder.uri.toString();
+    if (!cache[firstKey]) {
+      cache[firstKey] = await loadRegistry(firstFolder.uri);
+    }
+    return cache[firstKey];
+  }
+  return null;
+}
+function setRegistry(folderUri, registry) {
+  const folderKey = folderUri.toString();
+  cache[folderKey] = registry;
+}
+function clearCache() {
+  for (const key of Object.keys(cache)) {
+    delete cache[key];
+  }
+}
+async function getAllRegistries() {
+  const registries = [];
+  for (const value of Object.values(cache)) {
+    if (value && !(value instanceof Promise)) {
+      registries.push(value);
+    }
+  }
+  return registries;
+}
+
+// src/registry/watcher.ts
+var watchers = /* @__PURE__ */ new Map();
+function setupRegistryWatcher() {
+  const folders = import_vscode3.workspace.workspaceFolders;
+  if (!folders) {
+    return;
+  }
+  for (const folder of folders) {
+    const registryUri = resolveRegistryPath(folder.uri);
+    const watcherKey = folder.uri.toString();
+    if (watchers.has(watcherKey)) {
+      continue;
+    }
+    const watcher = import_vscode3.workspace.createFileSystemWatcher(
+      registryUri.fsPath,
+      false,
+      false,
+      false
+    );
+    watcher.onDidChange(async () => {
+      const registry = await loadRegistry(folder.uri);
+      setRegistry(folder.uri, registry);
+    });
+    watcher.onDidCreate(async () => {
+      const registry = await loadRegistry(folder.uri);
+      setRegistry(folder.uri, registry);
+    });
+    watcher.onDidDelete(() => {
+      setRegistry(folder.uri, null);
+    });
+    watchers.set(watcherKey, watcher);
+  }
+}
+function refreshAllRegistries() {
+  clearCache();
+  const folders = import_vscode3.workspace.workspaceFolders;
+  if (!folders) {
+    return Promise.resolve();
+  }
+  const promises = folders.map(async (folder) => {
+    const registry = await loadRegistry(folder.uri);
+    setRegistry(folder.uri, registry);
+  });
+  return Promise.all(promises).then(() => void 0);
+}
+
+// src/features/completion.ts
+var import_vscode5 = require("vscode");
+
+// src/utils/config.ts
+var import_vscode4 = require("vscode");
+function getSemiconsConfig(folder) {
+  const config = import_vscode4.workspace.getConfiguration("semicons", folder);
+  return {
+    registryPath: config.get("registryPath", "src/icons.generated/registry.json"),
+    localIconDir: config.get("localIconDir", "icons/local"),
+    iconComponentName: config.get("iconComponentName", "Icon")
+  };
+}
+
+// src/features/completion.ts
+function registerCompletionProvider() {
+  const provider = import_vscode5.languages.registerCompletionItemProvider(
+    [
+      { language: "typescriptreact" },
+      { language: "javascriptreact" },
+      { language: "vue" },
+      { language: "astro" }
+    ],
+    {
+      async provideCompletionItems(document, position, token) {
+        const registry = await getRegistryForFile(document.uri);
+        if (!registry || !registry.tokens) {
+          return [];
+        }
+        const config = getSemiconsConfig();
+        const iconName = config.iconComponentName;
+        const line = document.lineAt(position.line).text;
+        const linePrefix = line.substring(0, position.character);
+        const iconPattern = new RegExp(`<${iconName}\\s+[^>]*name\\s*=\\s*["']`, "g");
+        const vuePattern = new RegExp(`:${iconName}\\s*:\\s*name\\s*=\\s*["']`, "g");
+        const isInIconName = iconPattern.test(linePrefix) || vuePattern.test(linePrefix);
+        if (!isInIconName) {
+          return [];
+        }
+        const items = [];
+        for (const token2 of registry.tokens) {
+          const deprecated = token2.meta.deprecated;
+          const category = token2.name.split(":")[0];
+          const item = new import_vscode5.CompletionItem(
+            token2.name,
+            import_vscode5.CompletionItemKind.EnumMember
+          );
+          let detail = category;
+          if (deprecated) {
+            detail += " (deprecated)";
+          }
+          item.detail = detail;
+          const docLines = [];
+          if (token2.a11y?.label) {
+            docLines.push(`a11y: "${token2.a11y.label}"`);
+          }
+          if (token2.meta.description) {
+            docLines.push(token2.meta.description);
+          }
+          if (deprecated) {
+            docLines.push(`\u26A0\uFE0F Deprecated: ${typeof deprecated === "string" ? deprecated : "This icon is deprecated"}`);
+          }
+          const doc = new import_vscode5.MarkdownString();
+          doc.value = docLines.join("\n\n");
+          item.documentation = doc;
+          item.insertText = token2.name;
+          item.range = void 0;
+          items.push(item);
+        }
+        return items;
+      }
+    },
+    '"',
+    // Trigger on quote
+    "'"
+    // Trigger on single quote
+  );
+  return provider;
+}
+
+// src/features/hover.ts
+var import_vscode7 = require("vscode");
+
+// src/utils/tokenParse.ts
+var import_vscode6 = require("vscode");
+var ICON_TAG_REGEX = /<Icon\b/gi;
+var NAME_ATTR_REGEX = /\s+name\s*=\s*["']([^"']+)["']/g;
+var VUE_NAME_ATTR_REGEX = /\s+:name\s*=\s*["']([^"']+)["']/g;
+function findIconTokens(document) {
+  const text = document.getText();
+  const matches = [];
+  let match;
+  while ((match = ICON_TAG_REGEX.exec(text)) !== null) {
+    const tagStart = match.index;
+    const tagEnd = tagStart + match[0].length;
+    const remainingText = text.substring(tagEnd);
+    let nameMatch;
+    const nameRegex = new RegExp(NAME_ATTR_REGEX);
+    while ((nameMatch = nameRegex.exec(remainingText)) !== null) {
+      const nameStart = tagEnd + nameMatch.index;
+      const nameEnd = nameStart + nameMatch[0].length;
+      const nameValue = nameMatch[1];
+      const startPos = document.positionAt(nameStart);
+      const endPos = document.positionAt(nameEnd);
+      matches.push({
+        name: nameValue,
+        range: new import_vscode6.Range(startPos, endPos),
+        isAttributeValue: true
+      });
+    }
+    const vueNameRegex = new RegExp(VUE_NAME_ATTR_REGEX);
+    while ((nameMatch = vueNameRegex.exec(remainingText)) !== null) {
+      const nameStart = tagEnd + nameMatch.index;
+      const nameEnd = nameStart + nameMatch[0].length;
+      const nameValue = nameMatch[1];
+      const startPos = document.positionAt(nameStart);
+      const endPos = document.positionAt(nameEnd);
+      matches.push({
+        name: nameValue,
+        range: new import_vscode6.Range(startPos, endPos),
+        isAttributeValue: true
+      });
+    }
+  }
+  return matches;
+}
+function extractTokenNameAtPosition(document, position) {
+  const matches = findIconTokens(document);
+  for (const match of matches) {
+    if (match.range.contains(position)) {
+      return match.name;
+    }
+  }
+  return null;
+}
+
+// src/features/hover.ts
+function registerHoverProvider() {
+  const provider = import_vscode7.languages.registerHoverProvider(
+    [
+      { language: "typescriptreact" },
+      { language: "javascriptreact" },
+      { language: "vue" },
+      { language: "astro" }
+    ],
+    {
+      async provideHover(document, position, cancellationToken) {
+        const registry = await getRegistryForFile(document.uri);
+        if (!registry || !registry.tokens) {
+          return null;
+        }
+        const tokenName = extractTokenNameAtPosition(document, position);
+        if (!tokenName) {
+          return null;
+        }
+        const foundToken = registry.tokens.find((t) => t.name === tokenName);
+        if (!foundToken) {
+          return null;
+        }
+        const markdown = new import_vscode7.MarkdownString();
+        markdown.isTrusted = true;
+        const deprecated = foundToken.meta.deprecated;
+        const theme = registry.defaultTheme;
+        const assetRef = foundToken.themes[theme] || Object.values(foundToken.themes)[0];
+        const lines = [];
+        if (deprecated) {
+          lines.push(`~~${foundToken.name}~~ \u26A0\uFE0F`);
+        } else {
+          lines.push(`**${foundToken.name}**`);
+        }
+        lines.push(`\`${assetRef}\``);
+        if (foundToken.a11y?.label) {
+          lines.push(`a11y: "${foundToken.a11y.label}"`);
+        }
+        if (foundToken.meta.tags && foundToken.meta.tags.length > 0) {
+          lines.push(`tags: ${foundToken.meta.tags.join(", ")}`);
+        }
+        const previewCommand = `[Preview icon](command:semicons.previewIcon?${encodeURIComponent(JSON.stringify([foundToken.name]))})`;
+        lines.push("", previewCommand);
+        markdown.value = lines.join("\n\n");
+        return new import_vscode7.Hover(markdown);
+      }
+    }
+  );
+  return provider;
+}
+
+// src/features/diagnostics.ts
+var import_vscode8 = require("vscode");
+var TOKEN_PATTERN = /^[a-z][a-z0-9-]*:[a-zA-Z0-9][a-zA-Z0-9._/-]*$/;
+var DiagnosticsManager = class {
+  collection;
+  disposables = [];
+  constructor() {
+    this.collection = import_vscode8.languages.createDiagnosticCollection("semicons");
+  }
+  async updateDocument(document) {
+    const registry = await getRegistryForFile(document.uri);
+    const diagnostics = [];
+    const matches = findIconTokens(document);
+    for (const match of matches) {
+      const { name, range } = match;
+      if (!TOKEN_PATTERN.test(name)) {
+        diagnostics.push(new import_vscode8.Diagnostic(
+          range,
+          `Invalid token format. Expected "category:name" (e.g., "navigation:menu")`,
+          import_vscode8.DiagnosticSeverity.Error
+        ));
+        continue;
+      }
+      if (!registry || !registry.tokens) {
+        continue;
+      }
+      const token = registry.tokens.find((t) => t.name === name);
+      if (!token) {
+        diagnostics.push(new import_vscode8.Diagnostic(
+          range,
+          `Icon token "${name}" not found in registry`,
+          import_vscode8.DiagnosticSeverity.Error
+        ));
+      } else if (token.meta.deprecated) {
+        const deprecationMessage = typeof token.meta.deprecated === "string" ? `Deprecated: ${token.meta.deprecated}` : "This icon is deprecated";
+        diagnostics.push(new import_vscode8.Diagnostic(
+          range,
+          `\u26A0\uFE0F ${deprecationMessage}`,
+          import_vscode8.DiagnosticSeverity.Warning
+        ));
+      }
+    }
+    this.collection.set(document.uri, diagnostics);
+  }
+  clear() {
+    this.collection.clear();
+  }
+  dispose() {
+    this.collection.dispose();
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+  }
+};
+function registerDiagnosticsProvider(manager) {
+  const disposables2 = [];
+  const languagesToRegister = [
+    "typescriptreact",
+    "javascriptreact",
+    "vue",
+    "astro"
+  ];
+  for (const language of languagesToRegister) {
+    const pattern = `**/*.${language === "typescriptreact" || language === "javascriptreact" ? "tsx" : language === "vue" ? "vue" : "astro"}`;
+    const watcher = import_vscode8.workspace.createFileSystemWatcher(pattern);
+    watcher.onDidChange(async (uri) => {
+      const document = await import_vscode8.workspace.openTextDocument(uri);
+      await manager.updateDocument(document);
+    });
+    disposables2.push(watcher);
+  }
+  return import_vscode8.Disposable.from(...disposables2);
+}
+
+// src/features/commands.ts
+var import_vscode11 = require("vscode");
+
+// src/views/previewWebview.ts
+var import_vscode10 = require("vscode");
+
+// src/utils/path.ts
+var import_vscode9 = require("vscode");
+function parseAssetRef(assetRef) {
+  const match = assetRef.match(/^([^:]+):(.+)$/);
+  if (!match) {
+    return null;
+  }
+  return { namespace: match[1], id: match[2] };
+}
+async function resolveAssetToFileUri(assetRef, folder) {
+  const parsed = parseAssetRef(assetRef);
+  if (!parsed) {
+    return null;
+  }
+  const { namespace, id } = parsed;
+  if (namespace === "local") {
+    const config = getSemiconsConfig(folder);
+    const filePath = `${config.localIconDir}/${id}.svg`;
+    const fileUri = import_vscode9.Uri.joinPath(folder, filePath);
+    try {
+      await import_vscode9.workspace.fs.stat(fileUri);
+      return fileUri;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function readSvgContent(fileUri) {
+  try {
+    const bytes = await import_vscode9.workspace.fs.readFile(fileUri);
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+// src/views/previewWebview.ts
+var PreviewWebview = class {
+  panel = null;
+  state = null;
+  async show(token, registry, folderUri) {
+    this.state = { token, registry, folderUri };
+    if (this.panel) {
+      this.panel.reveal(import_vscode10.ViewColumn.Beside);
+      this.updatePanel();
+    } else {
+      this.panel = import_vscode10.window.createWebviewPanel(
+        "semiconsPreview",
+        `Preview: ${token.name}`,
+        import_vscode10.ViewColumn.Beside,
+        {
+          enableScripts: true,
+          localResourceRoots: [folderUri]
+        }
+      );
+      this.panel.onDidDispose(() => {
+        this.panel = null;
+        this.state = null;
+      });
+      this.updatePanel();
+    }
+  }
+  async updatePanel() {
+    if (!this.panel || !this.state) {
+      return;
+    }
+    const { token, registry, folderUri } = this.state;
+    const theme = registry.defaultTheme;
+    const assetRef = token.themes[theme] || Object.values(token.themes)[0];
+    const fileUri = await resolveAssetToFileUri(assetRef, folderUri);
+    let svgContent = null;
+    let svgExists = false;
+    if (fileUri) {
+      svgContent = await readSvgContent(fileUri);
+      svgExists = svgContent !== null;
+    }
+    const previewHtml = svgExists && svgContent ? this.wrapSvg(svgContent) : this.createPlaceholder(token.name, assetRef, svgExists);
+    const html = this.buildHtml(token, registry, assetRef, previewHtml);
+    this.panel.webview.html = html;
+  }
+  wrapSvg(svg) {
+    return svg.replace(/\s+width="[^"]*"/g, "").replace(/\s+height="[^"]*"/g, "").replace(/\s+viewBox="[^"]*"/g, "").replace(/^<svg/, '<svg width="100%" height="100%" viewBox="0 0 24 24"');
+  }
+  createPlaceholder(name, assetRef, fileExists) {
+    return `
+      <div class="placeholder">
+        <div class="placeholder-icon">
+          <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+            <rect x="3" y="3" width="18" height="18" rx="2"/>
+            <line x1="9" y1="9" x2="15" y2="15"/>
+            <line x1="15" y1="9" x2="9" y2="15"/>
+          </svg>
+        </div>
+        <p class="placeholder-text">${fileExists ? "Preview unavailable" : "File not found"}</p>
+        <p class="placeholder-ref">${assetRef}</p>
+        ${!fileExists ? `<p class="placeholder-hint">Expected: ${name.replace("local:", "icons/local/") + ".svg"}</p>` : ""}
+      </div>
+    `;
+  }
+  buildHtml(token, registry, assetRef, previewHtml) {
+    const deprecated = token.meta.deprecated;
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${token.name}</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      margin: 0;
+      padding: 16px;
+      background: #1e1e2e;
+      color: #cdd6f4;
+    }
+    .header {
+      margin-bottom: 16px;
+    }
+    .token-name {
+      font-size: 18px;
+      font-weight: 600;
+      margin: 0;
+    }
+    .token-name.deprecated {
+      text-decoration: line-through;
+      opacity: 0.7;
+    }
+    .token-ref {
+      font-family: 'Fira Code', monospace;
+      font-size: 12px;
+      color: #a6adc8;
+      background: #313244;
+      padding: 2px 8px;
+      border-radius: 4px;
+    }
+    .section {
+      margin-bottom: 16px;
+    }
+    .section-title {
+      font-size: 12px;
+      text-transform: uppercase;
+      color: #6c7086;
+      margin-bottom: 8px;
+    }
+    .preview-container {
+      background: #181825;
+      border-radius: 8px;
+      padding: 24px;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 120px;
+    }
+    .preview-container svg {
+      max-width: 100%;
+      max-height: 100px;
+    }
+    .placeholder {
+      text-align: center;
+      padding: 24px;
+    }
+    .placeholder-icon {
+      opacity: 0.3;
+      margin-bottom: 8px;
+    }
+    .placeholder-text {
+      font-size: 14px;
+      color: #a6adc8;
+      margin: 0 0 4px 0;
+    }
+    .placeholder-ref {
+      font-family: 'Fira Code', monospace;
+      font-size: 11px;
+      color: #6c7086;
+      margin: 0 0 8px 0;
+    }
+    .placeholder-hint {
+      font-size: 11px;
+      color: #f38ba8;
+      margin: 0;
+    }
+    .meta-row {
+      display: flex;
+      gap: 8px;
+      flex-wrap: wrap;
+    }
+    .tag {
+      font-size: 11px;
+      background: #313244;
+      padding: 2px 8px;
+      border-radius: 4px;
+    }
+    .warning {
+      background: #f9e2af;
+      color: #1e1e2e;
+      padding: 8px 12px;
+      border-radius: 4px;
+      font-size: 12px;
+      margin-top: 8px;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1 class="token-name ${deprecated ? "deprecated" : ""}">${token.name}</h1>
+    <span class="token-ref">${assetRef}</span>
+  </div>
+  
+  ${deprecated ? `<div class="warning">\u26A0\uFE0F Deprecated: ${typeof deprecated === "string" ? deprecated : "This icon is deprecated"}</div>` : ""}
+  
+  <div class="section">
+    <div class="section-title">Preview</div>
+    <div class="preview-container">
+      ${previewHtml}
+    </div>
+  </div>
+  
+  ${token.a11y?.label ? `
+  <div class="section">
+    <div class="section-title">Accessibility</div>
+    <div>aria-label: "${token.a11y.label}"</div>
+  </div>
+  ` : ""}
+  
+  ${token.meta.description ? `
+  <div class="section">
+    <div class="section-title">Description</div>
+    <div>${token.meta.description}</div>
+  </div>
+  ` : ""}
+  
+  ${token.meta.tags && token.meta.tags.length > 0 ? `
+  <div class="section">
+    <div class="section-title">Tags</div>
+    <div class="meta-row">
+      ${token.meta.tags.map((tag) => `<span class="tag">${tag}</span>`).join("")}
+    </div>
+  </div>
+  ` : ""}
+  
+  <div class="section">
+    <div class="section-title">Usage</div>
+    <pre style="background: #313244; padding: 12px; border-radius: 6px; overflow-x: auto;"><code>&lt;Icon name="${token.name}" /&gt;</code></pre>
+  </div>
+</body>
+</html>`;
+  }
+  dispose() {
+    if (this.panel) {
+      this.panel.dispose();
+      this.panel = null;
+    }
+    this.state = null;
+  }
+};
+
+// src/features/commands.ts
+var previewWebview = new PreviewWebview();
+function registerCommands() {
+  const disposables2 = [];
+  disposables2.push(import_vscode11.commands.registerCommand("semicons.refreshRegistry", async () => {
+    await refreshAllRegistries();
+    import_vscode11.window.showInformationMessage("Semicons registry refreshed");
+  }));
+  disposables2.push(import_vscode11.commands.registerCommand("semicons.searchToken", async () => {
+    const registries = await getAllRegistries();
+    if (registries.length === 0) {
+      import_vscode11.window.showWarningMessage("No registry found. Run pnpm semicons generate first.");
+      return;
+    }
+    const tokens = [];
+    for (const registry of registries) {
+      if (registry && registry.tokens) {
+        for (const token2 of registry.tokens) {
+          tokens.push({ name: token2.name, registry });
+        }
+      }
+    }
+    const items = tokens.map((t) => ({
+      label: t.name,
+      detail: t.name.split(":")[0],
+      description: t.registry.tokens.find((tok) => tok.name === t.name)?.meta.deprecated ? "(deprecated)" : void 0
+    }));
+    const selected = await import_vscode11.window.showQuickPick(items, {
+      placeHolder: "Search for an icon token...",
+      matchOnDescription: true,
+      matchOnDetail: true
+    });
+    if (!selected) {
+      return;
+    }
+    const tokenName = selected.label;
+    let foundRegistry = null;
+    let foundFolder;
+    for (const folder of import_vscode11.workspace.workspaceFolders || []) {
+      const registry = await getRegistryForFile(folder.uri);
+      if (registry?.tokens.some((t) => t.name === tokenName)) {
+        foundRegistry = registry;
+        foundFolder = folder.uri;
+        break;
+      }
+    }
+    if (!foundRegistry || !foundFolder) {
+      import_vscode11.window.showErrorMessage("Token registry not found");
+      return;
+    }
+    const token = foundRegistry.tokens.find((t) => t.name === tokenName);
+    if (!token) {
+      return;
+    }
+    const editor = import_vscode11.window.activeTextEditor;
+    if (editor) {
+      const insertText = `name="${tokenName}"`;
+      editor.edit((editBuilder) => {
+        editBuilder.insert(editor.selection.active, insertText);
+      });
+    } else {
+      await import_vscode11.commands.executeCommand("editor.action.clipboardCopyAction");
+      import_vscode11.window.showInformationMessage(`Token "${tokenName}" copied to clipboard`);
+    }
+  }));
+  disposables2.push(import_vscode11.commands.registerCommand("semicons.previewIcon", async (tokenName) => {
+    if (!tokenName) {
+      const editor = import_vscode11.window.activeTextEditor;
+      if (editor) {
+        const token = await getTokenAtCursor(editor.document, editor.selection.active);
+        if (token) {
+          tokenName = token;
+        }
+      }
+    }
+    if (!tokenName) {
+      import_vscode11.window.showWarningMessage("No token found at cursor");
+      return;
+    }
+    const registries = await getAllRegistries();
+    for (const registry of registries) {
+      if (registry?.tokens) {
+        const token = registry.tokens.find((t) => t.name === tokenName);
+        if (token) {
+          const folder = import_vscode11.workspace.workspaceFolders?.find(async (f) => {
+            const allRegs = await getAllRegistries();
+            const reg = allRegs.find((r) => r === registry);
+            return reg !== void 0;
+          });
+          if (folder) {
+            await previewWebview.show(token, registry, folder.uri);
+            return;
+          }
+        }
+      }
+    }
+    import_vscode11.window.showErrorMessage(`Token "${tokenName}" not found in registry`);
+  }));
+  return import_vscode11.Disposable.from(...disposables2);
+}
+async function getTokenAtCursor(document, position) {
+  const line = document.getText().split("\n")[position.line];
+  const match = line.match(/name\s*=\s*["']([^"']+)["']/);
+  return match ? match[1] : null;
+}
+
+// src/extension.ts
+var diagnosticsManager = null;
+var disposables = [];
+async function activate(context) {
+  await refreshAllRegistries();
+  setupRegistryWatcher();
+  disposables.push(registerCompletionProvider());
+  disposables.push(registerHoverProvider());
+  diagnosticsManager = new DiagnosticsManager();
+  disposables.push(registerDiagnosticsProvider(diagnosticsManager));
+  disposables.push(registerCommands());
+  const registries = await getAllRegistries();
+  if (registries.length > 0) {
+    import_vscode12.window.setStatusBarMessage("Semicons loaded", 3e3);
+  } else {
+    import_vscode12.window.showWarningMessage(
+      'Semicons: No registry found. Run "pnpm semicons generate" to create registry.json',
+      "Generate Now"
+    ).then((action) => {
+      if (action === "Generate Now") {
+        import_vscode12.commands.executeCommand("workbench.action.terminal.runSelectedText");
+      }
+    });
+  }
+  import_vscode12.workspace.onDidChangeTextDocument((event) => {
+    if (diagnosticsManager) {
+      diagnosticsManager.updateDocument(event.document);
+    }
+  });
+  import_vscode12.window.onDidChangeActiveTextEditor((editor) => {
+    if (editor && diagnosticsManager) {
+      diagnosticsManager.updateDocument(editor.document);
+    }
+  });
+  context.subscriptions.push({
+    dispose: () => {
+      for (const d of disposables) {
+        d.dispose();
+      }
+      disposables.length = 0;
+      if (diagnosticsManager) {
+        diagnosticsManager.dispose();
+        diagnosticsManager = null;
+      }
+    }
+  });
+}
+function deactivate() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate,
+  deactivate
+});
+//# sourceMappingURL=extension.js.map