@birdcc/parser 0.0.1-alpha.0 → 0.0.1-alpha.1

package/src/runtime.ts

@@ -1,64 +0,0 @@
-import { Language, Parser } from "web-tree-sitter";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-const DEFAULT_LANGUAGE_WASM_PATHS = [
-  fileURLToPath(new URL("./tree-sitter-birdcc.wasm", import.meta.url)),
-  fileURLToPath(new URL("../src/tree-sitter-birdcc.wasm", import.meta.url)),
-];
-
-let parserPromise: Promise<Parser> | null = null;
-let languageWasmPaths: string[] = [...DEFAULT_LANGUAGE_WASM_PATHS];
-
-const loadLanguage = async (): Promise<Language> => {
-  let lastError: unknown;
-
-  for (const path of languageWasmPaths) {
-    if (!existsSync(path)) {
-      continue;
-    }
-
-    try {
-      return await Language.load(path);
-    } catch (error) {
-      lastError = error;
-    }
-  }
-
-  const errorMessage =
-    lastError instanceof Error ? lastError.message : String(lastError);
-  const availablePaths = languageWasmPaths.join(", ");
-  throw new Error(
-    `Unable to load Tree-sitter WASM language from any candidate path: ${availablePaths}. Last error: ${errorMessage}`,
-  );
-};
-
-const createParser = async (): Promise<Parser> => {
-  await Parser.init();
-  const language = await loadLanguage();
-
-  const parser = new Parser();
-  parser.setLanguage(language);
-  return parser;
-};
-
-export const getParser = async (): Promise<Parser> => {
-  if (!parserPromise) {
-    parserPromise = createParser().catch((error: unknown) => {
-      parserPromise = null;
-      throw error;
-    });
-  }
-
-  return parserPromise;
-};
-
-export const resetParserRuntimeForTests = (): void => {
-  parserPromise = null;
-  languageWasmPaths = [...DEFAULT_LANGUAGE_WASM_PATHS];
-};
-
-export const setLanguageWasmPathsForTests = (paths: string[]): void => {
-  languageWasmPaths = [...paths];
-  parserPromise = null;
-};

package/src/tree.ts

@@ -1,210 +0,0 @@
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type { SourceRange } from "./types.js";
-
-const byteOffsetToCodeUnitIndex = (
-  bytes: Buffer,
-  byteOffset: number,
-): number => {
-  const clampedOffset = Math.max(0, Math.min(byteOffset, bytes.length));
-  return bytes.subarray(0, clampedOffset).toString("utf8").length;
-};
-
-let cachedSourceForBytes: string | null = null;
-let cachedUtf8Bytes: Buffer | null = null;
-let cachedSourceForLineStarts: string | null = null;
-let cachedLineStarts: number[] | null = null;
-const UTF8_CACHE_LIMIT_BYTES = 4 * 1024 * 1024;
-const UTF8_CACHE_TTL_MS = 30_000;
-let cachedUtf8BytesUpdatedAt = 0;
-let cachedUtf8BytesVersion = 0;
-let cachedLineStartsUpdatedAt = 0;
-let cachedLineStartsVersion = 0;
-
-const clearTextCaches = (): void => {
-  cachedSourceForBytes = null;
-  cachedUtf8Bytes = null;
-  cachedSourceForLineStarts = null;
-  cachedLineStarts = null;
-  cachedUtf8BytesUpdatedAt = 0;
-  cachedLineStartsUpdatedAt = 0;
-};
-
-const isUtf8CacheExpired = (): boolean => {
-  if (!cachedUtf8Bytes || cachedUtf8BytesUpdatedAt === 0) {
-    return true;
-  }
-
-  return Date.now() - cachedUtf8BytesUpdatedAt > UTF8_CACHE_TTL_MS;
-};
-
-const utf8BytesOf = (source: string): Buffer => {
-  const estimatedBytes = Buffer.byteLength(source, "utf8");
-  if (estimatedBytes > UTF8_CACHE_LIMIT_BYTES) {
-    if (
-      cachedUtf8Bytes &&
-      cachedUtf8Bytes.length > UTF8_CACHE_LIMIT_BYTES / 2
-    ) {
-      clearTextCaches();
-    }
-    return Buffer.from(source, "utf8");
-  }
-
-  if (
-    cachedSourceForBytes !== source ||
-    !cachedUtf8Bytes ||
-    isUtf8CacheExpired()
-  ) {
-    cachedSourceForBytes = source;
-    cachedUtf8Bytes = Buffer.from(source, "utf8");
-    cachedUtf8BytesVersion += 1;
-  }
-  cachedUtf8BytesUpdatedAt = Date.now();
-
-  return cachedUtf8Bytes;
-};
-
-const nodeCodeUnitSpan = (
-  node: SyntaxNode,
-  source: string,
-): {
-  startIndex: number;
-  endIndex: number;
-} => {
-  const startIndex = node.startIndex;
-  const endIndex = node.endIndex;
-
-  const inBounds =
-    startIndex >= 0 && endIndex >= startIndex && endIndex <= source.length;
-  if (inBounds && source.slice(startIndex, endIndex) === node.text) {
-    return { startIndex, endIndex };
-  }
-
-  const bytes = utf8BytesOf(source);
-  return {
-    startIndex: byteOffsetToCodeUnitIndex(bytes, startIndex),
-    endIndex: byteOffsetToCodeUnitIndex(bytes, endIndex),
-  };
-};
-
-const lineStartsOf = (source: string): number[] => {
-  const estimatedBytes = Buffer.byteLength(source, "utf8");
-  const canUseCache = estimatedBytes <= UTF8_CACHE_LIMIT_BYTES;
-  if (
-    canUseCache &&
-    cachedSourceForLineStarts === source &&
-    cachedLineStarts &&
-    Date.now() - cachedLineStartsUpdatedAt <= UTF8_CACHE_TTL_MS
-  ) {
-    cachedLineStartsUpdatedAt = Date.now();
-    return cachedLineStarts;
-  }
-
-  const starts = [0];
-
-  for (let index = 0; index < source.length; index += 1) {
-    if (source[index] === "\n") {
-      starts.push(index + 1);
-    }
-  }
-
-  if (canUseCache) {
-    cachedSourceForLineStarts = source;
-    cachedLineStarts = starts;
-    cachedLineStartsUpdatedAt = Date.now();
-    cachedLineStartsVersion += 1;
-  }
-
-  return starts;
-};
-
-const indexToLineColumn = (
-  codeUnitIndex: number,
-  lineStarts: number[],
-): { line: number; column: number } => {
-  let low = 0;
-  let high = lineStarts.length - 1;
-  let bestLineIndex = 0;
-
-  while (low <= high) {
-    const middle = Math.floor((low + high) / 2);
-    const lineStart = lineStarts[middle] ?? 0;
-
-    if (lineStart <= codeUnitIndex) {
-      bestLineIndex = middle;
-      low = middle + 1;
-    } else {
-      high = middle - 1;
-    }
-  }
-
-  const lineStart = lineStarts[bestLineIndex] ?? 0;
-  return {
-    line: bestLineIndex + 1,
-    column: codeUnitIndex - lineStart + 1,
-  };
-};
-
-export const toRange = (node: SyntaxNode, source?: string): SourceRange => {
-  if (!source) {
-    return {
-      line: node.startPosition.row + 1,
-      column: node.startPosition.column + 1,
-      endLine: node.endPosition.row + 1,
-      endColumn: node.endPosition.column + 1,
-    };
-  }
-
-  const { startIndex, endIndex } = nodeCodeUnitSpan(node, source);
-  const lineStarts = lineStartsOf(source);
-  const start = indexToLineColumn(startIndex, lineStarts);
-  const end = indexToLineColumn(endIndex, lineStarts);
-
-  return {
-    line: start.line,
-    column: start.column,
-    endLine: end.line,
-    endColumn: end.column,
-  };
-};
-
-export const mergeRanges = (
-  start: SourceRange,
-  end: SourceRange,
-): SourceRange => ({
-  line: start.line,
-  column: start.column,
-  endLine: end.endLine,
-  endColumn: end.endColumn,
-});
-
-export const textOf = (node: SyntaxNode, source: string): string => {
-  const { startIndex, endIndex } = nodeCodeUnitSpan(node, source);
-  return source.slice(startIndex, endIndex);
-};
-
-export const stripQuotes = (value: string): string =>
-  value.replace(/^['"]|['"]$/g, "");
-
-export const isPresentNode = (node: SyntaxNode | null): node is SyntaxNode =>
-  Boolean(node && !node.isMissing && !node.isError);
-
-export const cacheUtf8BytesForTests = (source: string): number =>
-  utf8BytesOf(source).length;
-
-export const getUtf8CacheStateForTests = (): {
-  hasCache: boolean;
-  byteLength: number;
-  utf8Version: number;
-  lineStartsVersion: number;
-} => ({
-  hasCache: Boolean(cachedUtf8Bytes),
-  byteLength: cachedUtf8Bytes?.length ?? 0,
-  utf8Version: cachedUtf8BytesVersion,
-  lineStartsVersion: cachedLineStartsVersion,
-});
-
-export const resetUtf8CacheForTests = (): void => {
-  clearTextCaches();
-  cachedUtf8BytesVersion = 0;
-  cachedLineStartsVersion = 0;
-};

package/src/types.ts

@@ -1,329 +0,0 @@
-/** 1-based source range used across parser/core/linter diagnostics. */
-export interface SourceRange {
-  line: number;
-  column: number;
-  endLine: number;
-  endColumn: number;
-}
-
-/** Parser issue emitted from Tree-sitter syntax recovery or runtime initialization. */
-export interface ParseIssue extends SourceRange {
-  code:
-    | "syntax/missing-semicolon"
-    | "syntax/unbalanced-brace"
-    | "parser/missing-symbol"
-    | "parser/syntax-error"
-    | "parser/runtime-error";
-  message: string;
-}
-
-interface DeclarationBase extends SourceRange {
-  kind:
-    | "include"
-    | "define"
-    | "router-id"
-    | "table"
-    | "protocol"
-    | "template"
-    | "filter"
-    | "function";
-}
-
-export interface IncludeDeclaration extends DeclarationBase {
-  kind: "include";
-  path: string;
-  pathRange: SourceRange;
-}
-
-export interface DefineDeclaration extends DeclarationBase {
-  kind: "define";
-  name: string;
-  nameRange: SourceRange;
-}
-
-export interface RouterIdDeclaration extends DeclarationBase {
-  kind: "router-id";
-  value: string;
-  valueKind: "ip" | "number" | "from" | "unknown";
-  valueRange: SourceRange;
-  fromSource?: "routing" | "dynamic";
-}
-
-export interface TableDeclaration extends DeclarationBase {
-  kind: "table";
-  tableType:
-    | "routing"
-    | "ipv4"
-    | "ipv6"
-    | "vpn4"
-    | "vpn6"
-    | "roa4"
-    | "roa6"
-    | "flow4"
-    | "flow6"
-    | "unknown";
-  tableTypeRange: SourceRange;
-  name: string;
-  nameRange: SourceRange;
-  attrsText?: string;
-  attrsRange?: SourceRange;
-}
-
-interface StatementBase extends SourceRange {
-  kind: "local-as" | "neighbor" | "import" | "export" | "channel";
-}
-
-export interface LocalAsStatement extends StatementBase {
-  kind: "local-as";
-  asn: string;
-  asnRange: SourceRange;
-}
-
-export interface NeighborStatement extends StatementBase {
-  kind: "neighbor";
-  address: string;
-  addressRange: SourceRange;
-  addressKind: "ip" | "other";
-  asn?: string;
-  asnRange?: SourceRange;
-}
-
-export interface ImportStatement extends StatementBase {
-  kind: "import";
-  mode: "all" | "none" | "filter" | "where" | "other";
-  filterName?: string;
-  filterNameRange?: SourceRange;
-  whereExpression?: string;
-  whereExpressionRange?: SourceRange;
-  clauseText?: string;
-}
-
-export interface ExportStatement extends StatementBase {
-  kind: "export";
-  mode: "all" | "none" | "filter" | "where" | "other";
-  filterName?: string;
-  filterNameRange?: SourceRange;
-  whereExpression?: string;
-  whereExpressionRange?: SourceRange;
-  clauseText?: string;
-}
-
-interface ChannelEntryBase extends SourceRange {
-  kind:
-    | "table"
-    | "import"
-    | "export"
-    | "limit"
-    | "debug"
-    | "keep-filtered"
-    | "other";
-}
-
-export interface ChannelTableEntry extends ChannelEntryBase {
-  kind: "table";
-  tableName: string;
-  tableNameRange: SourceRange;
-}
-
-export interface ChannelImportEntry extends ChannelEntryBase {
-  kind: "import";
-  mode: "all" | "none" | "filter" | "where" | "other";
-  filterName?: string;
-  filterNameRange?: SourceRange;
-  whereExpression?: string;
-  whereExpressionRange?: SourceRange;
-  clauseText?: string;
-}
-
-export interface ChannelExportEntry extends ChannelEntryBase {
-  kind: "export";
-  mode: "all" | "none" | "filter" | "where" | "other";
-  filterName?: string;
-  filterNameRange?: SourceRange;
-  whereExpression?: string;
-  whereExpressionRange?: SourceRange;
-  clauseText?: string;
-}
-
-export interface ChannelLimitEntry extends ChannelEntryBase {
-  kind: "limit";
-  direction: "import" | "receive" | "export";
-  value: string;
-  valueRange: SourceRange;
-  action?: string;
-  actionRange?: SourceRange;
-}
-
-export interface ChannelDebugEntry extends ChannelEntryBase {
-  kind: "debug";
-  clauseText: string;
-}
-
-export interface ChannelKeepFilteredEntry extends ChannelEntryBase {
-  kind: "keep-filtered";
-  value: string;
-  valueRange: SourceRange;
-}
-
-export interface ChannelOtherEntry extends ChannelEntryBase {
-  kind: "other";
-  text: string;
-}
-
-export type ChannelEntry =
-  | ChannelTableEntry
-  | ChannelImportEntry
-  | ChannelExportEntry
-  | ChannelLimitEntry
-  | ChannelDebugEntry
-  | ChannelKeepFilteredEntry
-  | ChannelOtherEntry;
-
-export interface ChannelStatement extends StatementBase {
-  kind: "channel";
-  channelType:
-    | "ipv4"
-    | "ipv6"
-    | "vpn4"
-    | "vpn6"
-    | "roa4"
-    | "roa6"
-    | "flow4"
-    | "flow6"
-    | "mpls"
-    | "unknown";
-  channelTypeRange: SourceRange;
-  entries: ChannelEntry[];
-}
-
-export interface OtherProtocolStatement extends SourceRange {
-  kind: "other";
-  text: string;
-}
-
-export type ProtocolStatement =
-  | LocalAsStatement
-  | NeighborStatement
-  | ImportStatement
-  | ExportStatement
-  | ChannelStatement
-  | OtherProtocolStatement;
-
-export interface ProtocolDeclaration extends DeclarationBase {
-  kind: "protocol";
-  protocolType: string;
-  protocolTypeRange: SourceRange;
-  name: string;
-  nameRange: SourceRange;
-  fromTemplate?: string;
-  fromTemplateRange?: SourceRange;
-  statements: ProtocolStatement[];
-}
-
-export interface TemplateDeclaration extends DeclarationBase {
-  kind: "template";
-  templateType: string;
-  templateTypeRange: SourceRange;
-  name: string;
-  nameRange: SourceRange;
-  fromTemplate?: string;
-  fromTemplateRange?: SourceRange;
-}
-
-export interface ExtractedLiteral extends SourceRange {
-  kind: "ip" | "prefix";
-  value: string;
-}
-
-export interface MatchExpression extends SourceRange {
-  operator: "~";
-  left: string;
-  right: string;
-}
-
-interface ControlStatementBase extends SourceRange {
-  kind: "if" | "accept" | "reject" | "return" | "case" | "expression" | "other";
-}
-
-export interface IfStatement extends ControlStatementBase {
-  kind: "if";
-  conditionText?: string;
-  thenText: string;
-  elseText?: string;
-}
-
-export interface AcceptStatement extends ControlStatementBase {
-  kind: "accept";
-}
-
-export interface RejectStatement extends ControlStatementBase {
-  kind: "reject";
-}
-
-export interface ReturnStatement extends ControlStatementBase {
-  kind: "return";
-  valueText?: string;
-}
-
-export interface CaseStatement extends ControlStatementBase {
-  kind: "case";
-  subjectText?: string;
-}
-
-export interface ExpressionStatement extends ControlStatementBase {
-  kind: "expression";
-  expressionText: string;
-}
-
-export interface OtherStatement extends ControlStatementBase {
-  kind: "other";
-  text: string;
-}
-
-export type FilterBodyStatement =
-  | IfStatement
-  | AcceptStatement
-  | RejectStatement
-  | ReturnStatement
-  | CaseStatement
-  | ExpressionStatement
-  | OtherStatement;
-
-export interface FilterDeclaration extends DeclarationBase {
-  kind: "filter";
-  name: string;
-  nameRange: SourceRange;
-  statements: FilterBodyStatement[];
-  literals: ExtractedLiteral[];
-  matches: MatchExpression[];
-}
-
-export interface FunctionDeclaration extends DeclarationBase {
-  kind: "function";
-  name: string;
-  nameRange: SourceRange;
-  statements: FilterBodyStatement[];
-  literals: ExtractedLiteral[];
-  matches: MatchExpression[];
-}
-
-export type BirdDeclaration =
-  | IncludeDeclaration
-  | DefineDeclaration
-  | RouterIdDeclaration
-  | TableDeclaration
-  | ProtocolDeclaration
-  | TemplateDeclaration
-  | FilterDeclaration
-  | FunctionDeclaration;
-
-export interface BirdProgram {
-  kind: "program";
-  declarations: BirdDeclaration[];
-}
-
-/** Result of parsing one BIRD config document. */
-export interface ParsedBirdDocument {
-  program: BirdProgram;
-  issues: ParseIssue[];
-}

package/test/fixtures.test.ts

@@ -1,48 +0,0 @@
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-import { parseBirdConfig } from "../src/index.js";
-
-const fixtureFiles = [
-  "basic.conf",
-  "bgp_advanced.conf",
-  "bogon.conf",
-  "protocol_phrases.conf",
-] as const;
-
-const readFixture = (name: string): string => {
-  const url = new URL(
-    `../../../../refer/BIRD-tm-language-grammar/sample/${name}`,
-    import.meta.url,
-  );
-  return readFileSync(url, "utf8");
-};
-
-describe("@birdcc/parser fixtures", () => {
-  for (const fileName of fixtureFiles) {
-    it(`parses fixture ${fileName}`, async () => {
-      const text = readFixture(fileName);
-      const parsed = await parseBirdConfig(text);
-
-      expect(parsed.program.declarations.length).toBeGreaterThan(0);
-      expect(
-        parsed.issues.filter((item) => item.code === "parser/syntax-error"),
-      ).toHaveLength(0);
-    });
-  }
-
-  it("extracts protocol statements from protocol_phrases.conf", async () => {
-    const text = readFixture("protocol_phrases.conf");
-    const parsed = await parseBirdConfig(text);
-
-    const protocols = parsed.program.declarations.filter(
-      (item) => item.kind === "protocol",
-    );
-    const statements = protocols.flatMap((protocol) =>
-      protocol.statements.map((item) => item.kind),
-    );
-
-    expect(statements).toContain("local-as");
-    expect(statements).toContain("import");
-    expect(statements).toContain("export");
-  });
-});

package/test/ip-literal-candidate.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  isIpLiteralCandidate,
-  isStrictIpLiteral,
-  isStrictIpv4Literal,
-  isStrictIpv6Literal,
-} from "../src/declarations/shared.js";
-
-describe("ip literal candidate helpers", () => {
-  it("accepts strict IPv4/IPv6 literals", () => {
-    expect(isStrictIpv4Literal("192.0.2.1")).toBe(true);
-    expect(isStrictIpv6Literal("2001:db8::1")).toBe(true);
-    expect(isStrictIpLiteral("192.0.2.1")).toBe(true);
-    expect(isStrictIpLiteral("2001:db8::1")).toBe(true);
-  });
-
-  it("rejects invalid strict literals", () => {
-    expect(isStrictIpv4Literal("203.0.113.999")).toBe(false);
-    expect(isStrictIpv6Literal("2001:db8::gg")).toBe(false);
-    expect(isStrictIpLiteral("not-an-ip")).toBe(false);
-  });
-
-  it("keeps ip-like malformed inputs as candidates for semantic diagnostics", () => {
-    expect(isIpLiteralCandidate("203.0.113.999")).toBe(true);
-    expect(isIpLiteralCandidate("2001:db8::fffff")).toBe(true);
-    expect(isIpLiteralCandidate("2001:db8:::1")).toBe(true);
-  });
-
-  it("filters out non-ip tokens and malformed shapes", () => {
-    expect(isIpLiteralCandidate("")).toBe(false);
-    expect(isIpLiteralCandidate("  ")).toBe(false);
-    expect(isIpLiteralCandidate("router-id")).toBe(false);
-    expect(isIpLiteralCandidate("203.0.113")).toBe(false);
-    expect(isIpLiteralCandidate("203..113.1")).toBe(false);
-    expect(isIpLiteralCandidate("::ffff:203.0.113.999")).toBe(false);
-    expect(isIpLiteralCandidate("2001:db8::gg")).toBe(false);
-    expect(isIpLiteralCandidate("2001:db8::1/64")).toBe(false);
-  });
-});