refrakt-md 0.5.0

package/src/extension.ts

@@ -0,0 +1,96 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import {
+  LanguageClient,
+  TransportKind,
+  type LanguageClientOptions,
+  type ServerOptions,
+} from 'vscode-languageclient/node';
+import { RuneInspectorProvider } from './inspector';
+
+let client: LanguageClient;
+let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+
+export function activate(context: vscode.ExtensionContext) {
+  const serverModule = path.join(__dirname, 'server.js');
+
+  const serverOptions: ServerOptions = {
+    run: { module: serverModule, transport: TransportKind.stdio },
+    debug: { module: serverModule, transport: TransportKind.stdio },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [{ scheme: 'file', language: 'markdown' }],
+    synchronize: {
+      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.md'),
+    },
+  };
+
+  client = new LanguageClient(
+    'refrakt-language-server',
+    'refrakt.md Language Server',
+    serverOptions,
+    clientOptions,
+  );
+
+  // Rune Inspector tree view
+  const inspectorProvider = new RuneInspectorProvider();
+  const treeView = vscode.window.createTreeView('refraktRuneInspector', {
+    treeDataProvider: inspectorProvider,
+  });
+  context.subscriptions.push(treeView);
+
+  // Request rune inspection from the language server
+  function requestInspection() {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor || editor.document.languageId !== 'markdown') {
+      inspectorProvider.refresh(null);
+      return;
+    }
+
+    const uri = editor.document.uri.toString();
+    const position = editor.selection.active;
+
+    client.sendRequest('refrakt/inspectRune', {
+      uri,
+      position: { line: position.line, character: position.character },
+    }).then(
+      (result) => inspectorProvider.refresh(result as any),
+      () => inspectorProvider.refresh(null),
+    );
+  }
+
+  // Debounced cursor change handler
+  function onCursorChange() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(requestInspection, 300);
+  }
+
+  // Wire up after client is ready
+  client.start().then(() => {
+    context.subscriptions.push(
+      vscode.window.onDidChangeTextEditorSelection(onCursorChange),
+      vscode.window.onDidChangeActiveTextEditor(onCursorChange),
+    );
+
+    // Initial inspection
+    requestInspection();
+  });
+
+  // Commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('refrakt.inspectRune', requestInspection),
+    vscode.commands.registerCommand('refrakt.copyInspectorNode', (node) => {
+      if (node) {
+        const json = inspectorProvider.getNodeJson(node);
+        vscode.env.clipboard.writeText(json);
+      }
+    }),
+  );
+}
+
+export function deactivate(): Thenable<void> | undefined {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  if (!client) return undefined;
+  return client.stop();
+}

package/src/inspector.ts

@@ -0,0 +1,215 @@
+import * as vscode from 'vscode';
+
+interface InspectorResult {
+  runeName: string;
+  stages: {
+    ast: object;
+    transform: object;
+    serialized: object;
+    identity: object | null;
+  };
+  identityError?: string;
+}
+
+export class InspectorNode {
+  constructor(
+    public readonly label: string,
+    public readonly description: string,
+    public readonly children: InspectorNode[],
+    public readonly data: unknown,
+    public readonly icon?: string,
+  ) {}
+
+  get collapsibleState(): vscode.TreeItemCollapsibleState {
+    return this.children.length > 0
+      ? vscode.TreeItemCollapsibleState.Expanded
+      : vscode.TreeItemCollapsibleState.None;
+  }
+}
+
+/**
+ * Build tree nodes from a JSON-like object, recursively.
+ */
+function buildObjectTree(obj: unknown, parentLabel?: string): InspectorNode[] {
+  if (obj === null || obj === undefined) {
+    return [new InspectorNode(parentLabel ?? 'null', 'null', [], obj)];
+  }
+
+  if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
+    return [new InspectorNode(parentLabel ?? String(obj), String(obj), [], obj)];
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item, i) => {
+      const label = getNodeLabel(item, i);
+      const desc = getNodeDescription(item);
+      const children = (typeof item === 'object' && item !== null)
+        ? buildObjectChildren(item)
+        : [];
+      return new InspectorNode(label, desc, children, item);
+    });
+  }
+
+  if (typeof obj === 'object') {
+    return buildObjectChildren(obj as Record<string, unknown>);
+  }
+
+  return [];
+}
+
+function buildObjectChildren(obj: Record<string, unknown>): InspectorNode[] {
+  const nodes: InspectorNode[] = [];
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined) continue;
+
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+      nodes.push(new InspectorNode(key, String(value), [], value));
+    } else if (Array.isArray(value)) {
+      const children = value.map((item, i) => {
+        const label = getNodeLabel(item, i);
+        const desc = getNodeDescription(item);
+        const childChildren = (typeof item === 'object' && item !== null)
+          ? buildObjectChildren(item as Record<string, unknown>)
+          : [];
+        return new InspectorNode(label, desc, childChildren, item);
+      });
+      nodes.push(new InspectorNode(key, `[${value.length}]`, children, value));
+    } else if (typeof value === 'object') {
+      const children = buildObjectChildren(value as Record<string, unknown>);
+      nodes.push(new InspectorNode(key, '', children, value));
+    }
+  }
+
+  return nodes;
+}
+
+/**
+ * Get a human-readable label for a tree node.
+ */
+function getNodeLabel(item: unknown, index: number): string {
+  if (item === null || item === undefined) return `[${index}]`;
+  if (typeof item !== 'object') return String(item);
+
+  const obj = item as Record<string, unknown>;
+
+  // Serialized tag nodes
+  if (obj.$$mdtype === 'Tag' && obj.name) {
+    const attrs = obj.attributes as Record<string, unknown> | undefined;
+    if (attrs?.typeof) return `${obj.name} [typeof="${attrs.typeof}"]`;
+    if (attrs?.class) return `${obj.name}.${String(attrs.class).split(' ').join('.')}`;
+    if (attrs?.['data-name']) return `${obj.name} [${attrs['data-name']}]`;
+    if (attrs?.property) return `${obj.name} [property="${attrs.property}"]`;
+    return String(obj.name);
+  }
+
+  // AST child summary
+  if (obj.type) {
+    if (obj.tag) return `${obj.type}: ${obj.tag}`;
+    return String(obj.type);
+  }
+
+  // Text nodes
+  if (obj.text) return `"${String(obj.text).slice(0, 40)}"`;
+
+  return `[${index}]`;
+}
+
+/**
+ * Get a short description string for a tree node.
+ */
+function getNodeDescription(item: unknown): string {
+  if (item === null || item === undefined) return '';
+  if (typeof item !== 'object') return '';
+
+  const obj = item as Record<string, unknown>;
+  const attrs = obj.attributes as Record<string, unknown> | undefined;
+
+  if (attrs?.typeof) return String(attrs.typeof);
+  if (attrs?.class) return String(attrs.class);
+  if (attrs?.['data-name']) return String(attrs['data-name']);
+
+  return '';
+}
+
+const STAGE_ICONS: Record<string, vscode.ThemeIcon> = {
+  ast: new vscode.ThemeIcon('symbol-structure'),
+  transform: new vscode.ThemeIcon('symbol-method'),
+  serialized: new vscode.ThemeIcon('json'),
+  identity: new vscode.ThemeIcon('paintcan'),
+};
+
+export class RuneInspectorProvider implements vscode.TreeDataProvider<InspectorNode> {
+  private _onDidChangeTreeData = new vscode.EventEmitter<InspectorNode | undefined | null>();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  private rootNodes: InspectorNode[] = [];
+  private currentResult: InspectorResult | null = null;
+
+  refresh(result: InspectorResult | null): void {
+    this.currentResult = result;
+    this.rootNodes = result ? this.buildRootNodes(result) : [];
+    this._onDidChangeTreeData.fire(undefined);
+  }
+
+  getTreeItem(element: InspectorNode): vscode.TreeItem {
+    const item = new vscode.TreeItem(element.label, element.collapsibleState);
+    item.description = element.description;
+    item.tooltip = new vscode.MarkdownString(
+      '```json\n' + JSON.stringify(element.data, null, 2) + '\n```'
+    );
+    item.contextValue = 'inspectorNode';
+
+    if (element.icon && STAGE_ICONS[element.icon]) {
+      item.iconPath = STAGE_ICONS[element.icon];
+    }
+
+    return item;
+  }
+
+  getChildren(element?: InspectorNode): InspectorNode[] {
+    if (!element) {
+      if (this.rootNodes.length === 0) {
+        return [new InspectorNode('No rune at cursor', 'Move cursor inside a rune tag', [], null)];
+      }
+      return this.rootNodes;
+    }
+    return element.children;
+  }
+
+  getNodeJson(node: InspectorNode): string {
+    return JSON.stringify(node.data, null, 2);
+  }
+
+  private buildRootNodes(result: InspectorResult): InspectorNode[] {
+    const stages: InspectorNode[] = [];
+
+    // AST stage
+    const astChildren = buildObjectChildren(result.stages.ast as Record<string, unknown>);
+    const astNode = new InspectorNode('AST', result.runeName, astChildren, result.stages.ast, 'ast');
+    stages.push(astNode);
+
+    // Transform stage
+    const transformChildren = buildObjectChildren(result.stages.transform as Record<string, unknown>);
+    const transformNode = new InspectorNode('Transform', '', transformChildren, result.stages.transform, 'transform');
+    stages.push(transformNode);
+
+    // Serialized stage
+    const serializedChildren = buildObjectChildren(result.stages.serialized as Record<string, unknown>);
+    const serializedNode = new InspectorNode('Serialized', '', serializedChildren, result.stages.serialized, 'serialized');
+    stages.push(serializedNode);
+
+    // Identity Transform stage
+    if (result.stages.identity) {
+      const identityChildren = buildObjectChildren(result.stages.identity as Record<string, unknown>);
+      const identityNode = new InspectorNode('Identity Transform', '', identityChildren, result.stages.identity, 'identity');
+      stages.push(identityNode);
+    } else {
+      const errorMsg = result.identityError ?? 'Theme not available';
+      const identityNode = new InspectorNode('Identity Transform', errorMsg, [], null, 'identity');
+      stages.push(identityNode);
+    }
+
+    return stages;
+  }
+}

package/syntaxes/refrakt.tmLanguage.json

@@ -0,0 +1,77 @@
+{
+	"$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+	"scopeName": "text.html.markdown.refrakt",
+	"injectionSelector": "L:text.html.markdown, L:meta.paragraph.markdown, L:markup.list.markdown, L:markup.quote.markdown",
+	"patterns": [
+		{ "include": "#rune-closing-tag" },
+		{ "include": "#rune-tag" }
+	],
+	"repository": {
+		"rune-closing-tag": {
+			"name": "meta.tag.rune.closing.refrakt",
+			"match": "(\\{%)\\s*(/)([a-zA-Z][a-zA-Z0-9-]*)\\s*(%\\})",
+			"captures": {
+				"1": { "name": "punctuation.definition.tag.begin.rune.refrakt" },
+				"2": { "name": "punctuation.definition.tag.close.rune.refrakt" },
+				"3": { "name": "entity.name.tag.rune.refrakt" },
+				"4": { "name": "punctuation.definition.tag.end.rune.refrakt" }
+			}
+		},
+		"rune-tag": {
+			"name": "meta.tag.rune.refrakt",
+			"begin": "(\\{%)\\s*([a-zA-Z][a-zA-Z0-9-]*)",
+			"end": "(/?)(%\\})",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.rune.refrakt" },
+				"2": { "name": "entity.name.tag.rune.refrakt" }
+			},
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.self-close.rune.refrakt" },
+				"2": { "name": "punctuation.definition.tag.end.rune.refrakt" }
+			},
+			"patterns": [
+				{ "include": "#rune-attributes" }
+			]
+		},
+		"rune-attributes": {
+			"patterns": [
+				{ "include": "#rune-attribute-quoted" },
+				{ "include": "#rune-attribute-boolean" },
+				{ "include": "#rune-attribute-number" },
+				{ "include": "#rune-attribute-unquoted" }
+			]
+		},
+		"rune-attribute-quoted": {
+			"match": "([a-zA-Z][a-zA-Z0-9-]*)(=)(\"[^\"]*\")",
+			"captures": {
+				"1": { "name": "entity.other.attribute-name.rune.refrakt" },
+				"2": { "name": "punctuation.separator.key-value.rune.refrakt" },
+				"3": { "name": "string.quoted.double.rune.refrakt" }
+			}
+		},
+		"rune-attribute-boolean": {
+			"match": "([a-zA-Z][a-zA-Z0-9-]*)(=)(true|false)(?=\\s|%|/)",
+			"captures": {
+				"1": { "name": "entity.other.attribute-name.rune.refrakt" },
+				"2": { "name": "punctuation.separator.key-value.rune.refrakt" },
+				"3": { "name": "constant.language.boolean.rune.refrakt" }
+			}
+		},
+		"rune-attribute-number": {
+			"match": "([a-zA-Z][a-zA-Z0-9-]*)(=)([0-9]+(?:\\.[0-9]+)?)(?=\\s|%|/)",
+			"captures": {
+				"1": { "name": "entity.other.attribute-name.rune.refrakt" },
+				"2": { "name": "punctuation.separator.key-value.rune.refrakt" },
+				"3": { "name": "constant.numeric.rune.refrakt" }
+			}
+		},
+		"rune-attribute-unquoted": {
+			"match": "([a-zA-Z][a-zA-Z0-9-]*)(=)([^\\s\"%}/]+)",
+			"captures": {
+				"1": { "name": "entity.other.attribute-name.rune.refrakt" },
+				"2": { "name": "punctuation.separator.key-value.rune.refrakt" },
+				"3": { "name": "string.unquoted.rune.refrakt" }
+			}
+		}
+	}
+}