@power-seo/links

@power-seo/links

Build a directed link graph from your site's pages, detect orphan pages with zero inbound links, generate keyword-overlap-based link suggestions, and score link equity with a PageRank-style algorithm.

@power-seo/links gives you a complete internal linking intelligence layer for your SEO tooling. Internal link structure is one of the most actionable on-page SEO signals — it determines how search engines discover and understand your content, and how link equity flows through your site. Yet most SEO tools treat it as a secondary concern. This package makes it a first-class concern.

Given a list of pages and their outbound links, buildLinkGraph constructs a full directed graph in memory. From that graph you can immediately find orphan pages (pages that no other page links to — invisible to crawlers that start from the homepage), compute PageRank-style equity scores to understand which pages accumulate the most link authority, and generate contextual internal link suggestions based on keyword and topic overlap between pages.

The package is designed to integrate directly with @power-seo/audit for site-wide SEO audits, and with @power-seo/analytics for correlating link equity with traffic data. It is dependency-free, fully typed, and tree-shakeable.

Zero dependencies — no runtime dependencies; pure TypeScript computation.

Why @power-seo/links?

	Without	With
Orphan detection	❌ Manual crawl	✅ findOrphanPages() in-memory graph
Link suggestions	❌ Guesswork	✅ Keyword-overlap-based contextual suggestions
Link equity	❌ Third-party tools	✅ PageRank-style scoring built-in
Graph construction	❌ Build from scratch	✅ buildLinkGraph() — directed graph in one call
Audit integration	❌ Separate toolchain	✅ Designed to integrate with @power-seo/audit
TypeScript support	❌ Untyped	✅ Full type coverage for all graph structures
Zero dependencies	❌ External libs	✅ Pure TypeScript, no runtime dependencies

Features

• Directed link graph construction — buildLinkGraph(pages) builds an in-memory directed graph from page URL arrays, computing both outbound and inbound link sets for each node
• Orphan page detection — findOrphanPages(graph) returns all pages that have zero inbound internal links, making them invisible to crawlers following links from the homepage
• Keyword-overlap link suggestions — suggestLinks(pages, options?) compares page titles and content to find thematically related pages that should be linking to each other but are not
• PageRank-style link equity scoring — analyzeLinkEquity(graph, options?) runs a damping-factor iterative algorithm to assign a relative equity score to every node in the graph
• Configurable suggestion options — control minimum similarity threshold, maximum suggestions per page, and whether to include bidirectional suggestions
• Configurable equity options — set the damping factor (default 0.85), number of iterations, and convergence threshold for the PageRank algorithm
• Inbound and outbound link counts — every LinkNode in the graph exposes both inbound and outbound arrays plus inboundCount and outboundCount for direct inspection
• Normalized URL handling — URLs are normalized before graph construction to prevent duplicate nodes from trailing slashes or case differences
• Zero dependencies — no runtime dependencies; pure TypeScript computation

Comparison

Feature	@power-seo/links	Screaming Frog	Ahrefs	Custom scripts
Programmatic link graph	✅	❌	❌	Manual
Orphan page detection	✅	✅	✅	Manual
Keyword-based suggestions	✅	❌	❌	Manual
PageRank-style equity	✅	❌	✅	Manual
Audit integration	✅	❌	❌	—
Zero dependencies	✅	❌	❌	—
TypeScript-first	✅	❌	❌	—
Tree-shakeable	✅	❌	❌	—

Installation

npm install @power-seo/links

yarn add @power-seo/links

pnpm add @power-seo/links

Quick Start

import { buildLinkGraph, findOrphanPages, suggestLinks, analyzeLinkEquity } from '@power-seo/links';

// 1. Build the graph from your site's pages
const graph = buildLinkGraph([
  { url: 'https://example.com/', links: ['https://example.com/about', 'https://example.com/blog'] },
  { url: 'https://example.com/about', links: ['https://example.com/'] },
  { url: 'https://example.com/blog', links: ['https://example.com/'] },
  { url: 'https://example.com/orphan', links: [] },
]);

// 2. Find pages no other page links to
const orphans = findOrphanPages(graph);
// [{ url: 'https://example.com/orphan', title: undefined, outboundCount: 0 }]

// 3. Get link equity scores
const equityScores = analyzeLinkEquity(graph);
// [{ url: 'https://example.com/', score: 0.48, inboundCount: 2 }, { url: 'https://example.com/about', score: 0.18, inboundCount: 1 }, ...]

Usage

Build a Link Graph

buildLinkGraph accepts an array of PageData objects and returns a LinkGraph — a Map<string, LinkNode> keyed by normalized URL. Each LinkNode contains the page's URL, its set of outbound links, and the set of pages that link to it (inbound links).

import { buildLinkGraph } from '@power-seo/links';
import type { PageData, LinkGraph } from '@power-seo/links';

const pages: PageData[] = [
  {
    url: 'https://example.com/',
    links: ['https://example.com/blog', 'https://example.com/about', 'https://example.com/contact'],
  },
  {
    url: 'https://example.com/blog',
    links: [
      'https://example.com/',
      'https://example.com/blog/post-1',
      'https://example.com/blog/post-2',
    ],
  },
  {
    url: 'https://example.com/blog/post-1',
    links: ['https://example.com/blog'],
  },
  {
    url: 'https://example.com/blog/post-2',
    links: ['https://example.com/blog', 'https://example.com/blog/post-1'],
  },
  {
    url: 'https://example.com/about',
    links: ['https://example.com/'],
  },
  {
    url: 'https://example.com/contact',
    links: [],
  },
];

const graph: LinkGraph = buildLinkGraph(pages);

// Inspect a node
const blogNode = graph.nodes.get('https://example.com/blog');
console.log(blogNode?.inbound); // ['https://example.com/']
console.log(blogNode?.inboundCount); // 1
console.log(blogNode?.outbound); // ['https://example.com/', ...]
console.log(blogNode?.outboundCount); // ...

Find Orphan Pages

findOrphanPages iterates the graph and returns all nodes whose inboundCount is zero. These pages cannot be reached by following links from any other page — making them effectively invisible to Googlebot unless they appear in your sitemap.

import { buildLinkGraph, findOrphanPages } from '@power-seo/links';
import type { OrphanPage } from '@power-seo/links';

const graph = buildLinkGraph(pages);
const orphans: OrphanPage[] = findOrphanPages(graph);

orphans.forEach(({ url, outboundCount }) => {
  console.log(`Orphan page: ${url} (${outboundCount} outbound links)`);
});

// Example output:
// Orphan page: https://example.com/contact (0 outbound links)

Tip: Cross-reference orphan pages with your sitemap. Pages that appear in the sitemap but have no inbound links are priority candidates for internal linking improvements.

Generate Link Suggestions

suggestLinks analyzes page titles and content to find pairs of pages that share significant topical overlap but do not currently link to each other. It uses a term-frequency-based similarity algorithm that does not require an external NLP library.

import { suggestLinks } from '@power-seo/links';
import type { LinkSuggestion, LinkSuggestionOptions } from '@power-seo/links';

const pages = [
  {
    url: '/guide/react-seo',
    title: 'React SEO Guide',
    content:
      'Learn how to optimize React applications for search engines using meta tags, structured data, and server-side rendering.',
  },
  {
    url: '/guide/meta-tags',
    title: 'HTML Meta Tags Explained',
    content:
      'Meta tags control how search engines index your pages. The title tag and meta description are the most important.',
  },
  {
    url: '/guide/nextjs-setup',
    title: 'Next.js Project Setup',
    content:
      'Set up a Next.js application with TypeScript, ESLint, and Prettier for a production-ready project.',
  },
];

const options: LinkSuggestionOptions = {
  maxSuggestions: 3, // optional — cap suggestions per page (default: 20)
  minRelevance: 0.15, // optional — minimum overlap score 0-1 (default: 0.1)
};

const suggestions: LinkSuggestion[] = suggestLinks(pages, options);

suggestions.forEach(({ from, to, anchorText, relevanceScore }) => {
  console.log(`Link from ${from} to ${to}`);
  console.log(`  Suggested anchor: "${anchorText}" (score: ${relevanceScore.toFixed(2)})`);
});

Analyze Link Equity

analyzeLinkEquity runs a PageRank-style iterative algorithm over the graph and returns a LinkEquityScore[] array assigning each page a normalized equity score, sorted by score in descending order. Pages with many high-quality inbound links receive higher scores.

import { buildLinkGraph, analyzeLinkEquity } from '@power-seo/links';
import type { LinkEquityScore, LinkEquityOptions } from '@power-seo/links';

const graph = buildLinkGraph(pages);

const options: LinkEquityOptions = {
  damping: 0.85, // optional — PageRank damping factor (default: 0.85)
  iterations: 20, // optional — max iterations (default: 20)
};

const equityScores = analyzeLinkEquity(graph, options);

// Sort pages by equity score (highest first)
const ranked = equityScores.sort((a, b) => b.score - a.score);

ranked.forEach(({ url, score, inboundCount }) => {
  console.log(`${url}: equity=${score.toFixed(4)}, inbound=${inboundCount}`);
});

Integration with Audit

Combine @power-seo/links with @power-seo/audit to surface link issues as part of a full site audit.

import { buildLinkGraph, findOrphanPages, analyzeLinkEquity } from '@power-seo/links';
import { auditSite } from '@power-seo/audit';

const graph = buildLinkGraph(sitePages);
const orphans = findOrphanPages(graph);
const equityScores = analyzeLinkEquity(graph);
const equityMap = new Map(equityScores.map((eq) => [eq.url, eq]));

const auditReport = auditSite({ pages: sitePages });

// Enrich audit results with link equity data
const enrichedPages = auditReport.pages.map((page) => ({
  ...page,
  linkEquity: equityMap.get(page.url)?.score ?? 0,
  isOrphan: orphans.some((o) => o.url === page.url),
}));

API Reference

buildLinkGraph(pages)

Parameter	Type	Default	Description
pages	PageData[]	required	Array of pages with their URL and outbound link arrays

Returns LinkGraph — object with nodes: Map<string, LinkNode>, totalPages: number, totalLinks: number.

findOrphanPages(graph, entryPoints?)

Parameter	Type	Default	Description
graph	LinkGraph	required	A directed link graph built by buildLinkGraph
entryPoints	string[]	[]	URLs to exclude from orphan detection (e.g., homepage)

Returns OrphanPage[] — array of { url: string; title?: string; outboundCount: number } objects.

suggestLinks(pages, options?)

Parameter	Type	Default	Description
pages	PageData[]	required	Pages with url, title, and content for analysis
options.minRelevance	number	0.1	Minimum keyword overlap score (0–1) to include a suggestion
options.maxSuggestions	number	20	Maximum number of suggestions returned per source page

Returns LinkSuggestion[] — array of { from, to, anchorText, relevanceScore } objects.

analyzeLinkEquity(graph, options?)

Parameter	Type	Default	Description
graph	LinkGraph	required	A directed link graph built by buildLinkGraph
options.damping	number	0.85	PageRank damping factor — probability of following a link vs. jumping randomly
options.iterations	number	20	Maximum number of power-iteration steps

Returns LinkEquityScore[] — array sorted by score descending.

Types

import type {
  PageData, // { url: string; links: string[]; title?: string; content?: string }
  LinkNode, // { url: string; inbound: string[]; outbound: string[]; inboundCount: number; outboundCount: number }
  LinkGraph, // { nodes: Map<string, LinkNode>; totalPages: number; totalLinks: number }
  OrphanPage, // { url: string; title?: string; outboundCount: number }
  LinkSuggestion, // { from: string; to: string; anchorText: string; relevanceScore: number }
  LinkSuggestionOptions, // { maxSuggestions?: number; minRelevance?: number }
  LinkEquityScore, // { url: string; score: number; inboundCount: number }
  LinkEquityOptions, // { damping?: number; iterations?: number }
} from '@power-seo/links';

Use Cases

• Content audit tools — detect orphan pages and prioritize internal linking improvements across your site
• Headless CMS — run link analysis after every publish to keep the site graph healthy
• SEO dashboards — visualize link equity distribution and identify pages that need more inbound links
• CI/CD pipelines — fail builds when orphan pages exceed a configurable threshold
• Content strategy — use link suggestions to build topical clusters automatically

Architecture Overview

• Pure TypeScript — no compiled binary, no native modules
• Zero dependencies — no runtime dependencies; pure TypeScript computation
• Framework-agnostic — works in Next.js, Remix, Vite, Node.js, Edge, or any JS runtime
• SSR compatible — no browser-specific APIs; safe for server-side or CLI usage
• Edge runtime safe — no Node.js-specific APIs; runs in Cloudflare Workers, Vercel Edge, Deno
• Tree-shakeable — "sideEffects": false with named exports per function
• Dual ESM + CJS — ships both formats via tsup for any bundler or require() usage

Supply Chain Security

• No install scripts (postinstall, preinstall)
• No runtime network access
• No eval or dynamic code execution
• CI-signed builds — all releases published via verified github.com/CyberCraftBD/power-seo workflow
• Safe for SSR, Edge, and server environments

The @power-seo Ecosystem

All 17 packages are independently installable — use only what you need.

Package	Install	Description
@power-seo/core	npm i @power-seo/core	Framework-agnostic utilities, types, validators, and constants
@power-seo/react	npm i @power-seo/react	React SEO components — meta, Open Graph, Twitter Card, breadcrumbs
@power-seo/meta	npm i @power-seo/meta	SSR meta helpers for Next.js App Router, Remix v2, and generic SSR
@power-seo/schema	npm i @power-seo/schema	Type-safe JSON-LD structured data — 23 builders + 22 React components
@power-seo/content-analysis	npm i @power-seo/content-analysis	Yoast-style SEO content scoring engine with React components
@power-seo/readability	npm i @power-seo/readability	Readability scoring — Flesch-Kincaid, Gunning Fog, Coleman-Liau, ARI
@power-seo/preview	npm i @power-seo/preview	SERP, Open Graph, and Twitter/X Card preview generators
@power-seo/sitemap	npm i @power-seo/sitemap	XML sitemap generation, streaming, index splitting, and validation
@power-seo/redirects	npm i @power-seo/redirects	Redirect engine with Next.js, Remix, and Express adapters
@power-seo/links	npm i @power-seo/links	Link graph analysis — orphan detection, suggestions, equity scoring
@power-seo/audit	npm i @power-seo/audit	Full SEO audit engine — meta, content, structure, performance rules
@power-seo/images	npm i @power-seo/images	Image SEO — alt text, lazy loading, format analysis, image sitemaps
@power-seo/ai	npm i @power-seo/ai	LLM-agnostic AI prompt templates and parsers for SEO tasks
@power-seo/analytics	npm i @power-seo/analytics	Merge GSC + audit data, trend analysis, ranking insights, dashboard
@power-seo/search-console	npm i @power-seo/search-console	Google Search Console API — OAuth2, service account, URL inspection
@power-seo/integrations	npm i @power-seo/integrations	Semrush and Ahrefs API clients with rate limiting and pagination
@power-seo/tracking	npm i @power-seo/tracking	GA4, Clarity, PostHog, Plausible, Fathom — scripts + consent management

About CyberCraft Bangladesh

CyberCraft Bangladesh is a Bangladesh-based enterprise-grade software development and Full Stack SEO service provider company specializing in ERP system development, AI-powered SaaS and business applications, full-stack SEO services, custom website development, and scalable eCommerce platforms. We design and develop intelligent, automation-driven SaaS and enterprise solutions that help startups, SMEs, NGOs, educational institutes, and large organizations streamline operations, enhance digital visibility, and accelerate growth through modern cloud-native technologies.

© 2026 CyberCraft Bangladesh · Released under the MIT License