pi-hashline-edit-pro 6.1.2 → 6.2.0

package/src/outline/vendor/parsers/sass.ts

@@ -0,0 +1,416 @@
+/**
+ * Sass (indented syntax) tree-sitter symbol extractor.
+ *
+ * Tree-sitter grammar: bajrangCoder/tree-sitter-sass
+ * (https://github.com/bajrangCoder/tree-sitter-sass), MIT license.
+ * This is the tree-sitter grammar for the indented `.sass` dialect (whitespace-
+ * significant, no braces/semicolons). The grammar is not published on npm and
+ * ships no prebuilt WASM, so the repo vendors a compiled tree-sitter-sass.wasm
+ * under src/parsers/vendor/.
+ *
+ * Grammar node shapes:
+ *  - `$var: value` parses as a `declaration` with a `variable_name` child;
+ *    regular CSS properties parse as `declaration` with `property_name`.
+ *  - `@mixin name(params)` / `@function name(params)` use a `name` child.
+ *  - `@include name(...)` uses a `mixin_name` child.
+ *  - `@use`/`@forward`/`@import` hold the module path in a `string_value`.
+ */
+
+import type { Node } from "web-tree-sitter";
+import type { SymbolInfo, ImportInfo } from "../types.js";
+
+/**
+ * Extract structural symbols from Sass (indented syntax) source code.
+ */
+export function extractSass(
+  node: Node,
+  source: string,
+  depth: number,
+): SymbolInfo[] {
+  const results: SymbolInfo[] = [];
+  const MAX_DEPTH = depth + 10;
+
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+
+    const symbol = extractSassChild(child, source, depth, MAX_DEPTH);
+    if (symbol) results.push(symbol);
+  }
+
+  return results;
+}
+
+function extractSassChild(
+  child: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+): SymbolInfo | null {
+  switch (child.type) {
+    case "rule_set":
+      return extractRuleSet(child, source, depth, MAX_DEPTH);
+    case "mixin_statement":
+      return extractNamedBlock(
+        child,
+        source,
+        depth,
+        MAX_DEPTH,
+        "mixin",
+      );
+    case "function_statement":
+      return extractNamedBlock(
+        child,
+        source,
+        depth,
+        MAX_DEPTH,
+        "function",
+      );
+    case "media_statement":
+      return extractAtBlock(child, source, depth, MAX_DEPTH, extractMediaName);
+    case "keyframes_statement":
+      return extractKeyframes(child, source, depth, MAX_DEPTH);
+    case "declaration": {
+      // `$var: value` at top level parses as a declaration with variable_name.
+      const varName = childTextOfType(child, source, "variable_name");
+      if (varName && varName.startsWith("$")) {
+        return {
+          name: varName,
+          type: "variable",
+          startLine: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+        };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
+function extractNamedBlock(
+  child: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+  label: string,
+): SymbolInfo | null {
+  let name = "<unknown>";
+  let detail: string | undefined;
+
+  for (let i = 0; i < child.namedChildCount; i++) {
+    const c = child.namedChild(i);
+    if (!c) continue;
+    if (c.type === "name") {
+      name = source.slice(c.startIndex, c.endIndex);
+    } else if (c.type === "parameters") {
+      detail =
+        "(" +
+        source.slice(c.startIndex, c.endIndex).replace(/^\(|\)$/g, "") +
+        ")";
+    }
+  }
+
+  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
+  const symbol: SymbolInfo = {
+    name,
+    type: label,
+    startLine: sl,
+    endLine: el,
+    detail,
+  };
+
+  if (depth < MAX_DEPTH) {
+    const block = findChildByType(child, ["block"]);
+    if (block) {
+      const children = extractBlockChildren(block, source, depth + 1, MAX_DEPTH);
+      if (children.length > 0) symbol.children = children;
+    }
+  }
+
+  return symbol;
+}
+
+function extractRuleSet(
+  child: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+): SymbolInfo | null {
+  const selectors = findChildByType(child, ["selectors"]);
+  const name = selectors
+    ? source.slice(selectors.startIndex, selectors.endIndex).trim()
+    : "<unknown>";
+
+  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
+  const symbol: SymbolInfo = {
+    name,
+    // `%placeholder` selectors get their own type.
+    type: name.startsWith("%") ? "placeholder" : "ruleset",
+    startLine: sl,
+    endLine: el,
+  };
+
+  if (depth < MAX_DEPTH) {
+    const block = findChildByType(child, ["block"]);
+    if (block) {
+      const children = extractBlockChildren(block, source, depth + 1, MAX_DEPTH);
+      if (children.length > 0) symbol.children = children;
+    }
+  }
+
+  return symbol;
+}
+
+function extractAtBlock(
+  child: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+  nameOf: (node: Node, source: string) => string,
+): SymbolInfo | null {
+  const name = nameOf(child, source);
+  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
+  const symbol: SymbolInfo = {
+    name,
+    type: "at-rule",
+    startLine: sl,
+    endLine: el,
+  };
+
+  if (depth < MAX_DEPTH) {
+    const block = findChildByType(child, ["block"]);
+    if (block) {
+      const children = extractBlockChildren(block, source, depth + 1, MAX_DEPTH);
+      if (children.length > 0) symbol.children = children;
+    }
+  }
+
+  return symbol;
+}
+
+function extractMediaName(node: Node, source: string): string {
+  const start = source.slice(node.startIndex, node.endIndex).trim();
+  const newline = start.indexOf("\n");
+  return newline >= 0 ? start.slice(0, newline).trim() : start;
+}
+
+function extractKeyframes(
+  child: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+): SymbolInfo | null {
+  let name = "<unknown>";
+  const nameNode = findChildByType(child, ["keyframes_name"]);
+  if (nameNode) name = source.slice(nameNode.startIndex, nameNode.endIndex);
+
+  const [sl, el] = [child.startPosition.row + 1, child.endPosition.row + 1];
+  const symbol: SymbolInfo = {
+    name: `@keyframes ${name}`,
+    type: "keyframes",
+    startLine: sl,
+    endLine: el,
+  };
+
+  if (depth < MAX_DEPTH) {
+    const block = findChildByType(child, ["block"]);
+    if (block) {
+      const children: SymbolInfo[] = [];
+      for (let i = 0; i < block.namedChildCount; i++) {
+        const kb = block.namedChild(i);
+        if (!kb) continue;
+        if (kb.type === "keyframe_block") {
+          const stepText = source
+            .slice(kb.startIndex, kb.endIndex)
+            .split("\n")[0]
+            .trim();
+          children.push({
+            name: stepText,
+            type: "keyframe",
+            startLine: kb.startPosition.row + 1,
+            endLine: kb.endPosition.row + 1,
+          });
+        }
+      }
+      if (children.length > 0) symbol.children = children;
+    }
+  }
+
+  return symbol;
+}
+
+function extractBlockChildren(
+  block: Node,
+  source: string,
+  depth: number,
+  MAX_DEPTH: number,
+): SymbolInfo[] {
+  const results: SymbolInfo[] = [];
+
+  for (let i = 0; i < block.namedChildCount; i++) {
+    const child = block.namedChild(i);
+    if (!child) continue;
+
+    switch (child.type) {
+      case "rule_set":
+      case "media_statement":
+      case "keyframes_statement":
+      case "mixin_statement":
+      case "function_statement": {
+        const inner = extractSassChild(child, source, depth, MAX_DEPTH);
+        if (inner) results.push(inner);
+        break;
+      }
+      case "include_statement": {
+        const inc = extractInclude(child, source);
+        if (inc) results.push(inc);
+        break;
+      }
+      case "extend_statement": {
+        const ext = extractExtend(child, source);
+        if (ext) results.push(ext);
+        break;
+      }
+      case "declaration": {
+        // `$var: value` inside a block surfaces as a variable.
+        const varName = childTextOfType(child, source, "variable_name");
+        if (varName && varName.startsWith("$")) {
+          results.push({
+            name: varName,
+            type: "variable",
+            startLine: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+          });
+        }
+        break;
+      }
+    }
+  }
+
+  return results;
+}
+
+function extractInclude(child: Node, source: string): SymbolInfo | null {
+  let name: string | undefined;
+  let detail: string | undefined;
+
+  for (let i = 0; i < child.namedChildCount; i++) {
+    const c = child.namedChild(i);
+    if (!c) continue;
+    if (c.type === "mixin_name") {
+      name = source.slice(c.startIndex, c.endIndex);
+    } else if (c.type === "arguments") {
+      detail = source.slice(c.startIndex, c.endIndex);
+    }
+  }
+  if (!name) return null;
+
+  return {
+    name: `@include ${name}`,
+    type: "include",
+    startLine: child.startPosition.row + 1,
+    endLine: child.endPosition.row + 1,
+    detail,
+  };
+}
+
+function extractExtend(child: Node, source: string): SymbolInfo | null {
+  let target: string | undefined;
+  for (let i = 0; i < child.namedChildCount; i++) {
+    const c = child.namedChild(i);
+    if (!c) continue;
+    if (
+      c.type === "placeholder_selector" ||
+      c.type === "class_selector" ||
+      c.type === "id_selector" ||
+      c.type === "identifier"
+    ) {
+      target = source.slice(c.startIndex, c.endIndex);
+      break;
+    }
+  }
+  if (!target) return null;
+
+  return {
+    name: `@extend ${target}`,
+    type: "extend",
+    startLine: child.startPosition.row + 1,
+    endLine: child.endPosition.row + 1,
+  };
+}
+
+// ---- Sass imports ----
+
+/**
+ * Extract Sass imports: `@use`, `@forward`, and `@import` statements
+ * (indented syntax, but the directives use the same module-path strings).
+ */
+export function extractSassImports(
+  node: Node,
+  source: string,
+): ImportInfo[] {
+  const results: ImportInfo[] = [];
+
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+
+    let kind: string | null = null;
+    if (child.type === "use_statement") kind = "use";
+    else if (child.type === "forward_statement") kind = "forward";
+    else if (child.type === "import_statement") kind = "import";
+    else continue;
+
+    const path = valueStringOf(child, source);
+    if (!path) continue;
+
+    results.push({
+      source: path,
+      names: [path],
+      lineNumber: child.startPosition.row + 1,
+    });
+  }
+
+  return results;
+}
+
+function valueStringOf(node: Node, source: string): string | undefined {
+  // Direct string_value child first.
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && c.type === "string_value") {
+      return stripQuotes(source.slice(c.startIndex, c.endIndex));
+    }
+  }
+  return undefined;
+}
+
+function stripQuotes(s: string): string {
+  return s.replace(/^["']|["']$/g, "");
+}
+
+// ---- Shared helpers ----
+
+function findChildByType(node: Node, types: string[]): Node | null {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && types.includes(c.type)) return c;
+  }
+  return null;
+}
+
+/** Return the text of the first named child of a given type. */
+function childTextOfType(
+  node: Node,
+  source: string,
+  type: string,
+): string | undefined {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && c.type === type) {
+      return source.slice(c.startIndex, c.endIndex);
+    }
+  }
+  return undefined;
+}