recker 1.0.79 → 1.0.80-next.70ea84d

package/dist/browser/seo/keyword-campaign-seed-advanced.js

@@ -0,0 +1,269 @@
+import { DEFAULT_SERP_MIN_KEYWORD_LENGTH, normalizeKeyword, tokenizeForLongTail, } from './keyword-campaign-shared.js';
+function isLowValueLongTail(tokens) {
+    const normalized = tokens.map((value) => normalizeKeyword(value)).filter(Boolean);
+    if (normalized.length === 0)
+        return true;
+    if (normalized.length === 1)
+        return true;
+    if (new Set(normalized).size === 1)
+        return true;
+    if (normalized.every((token) => token.length <= 3))
+        return true;
+    if (normalized.length <= 3 && normalized.every((token) => token.length <= 4))
+        return true;
+    const shortTokenCount = normalized.filter((token) => token.length <= 2).length;
+    if (shortTokenCount >= Math.max(1, Math.floor(normalized.length / 2)))
+        return true;
+    return normalized.some((token) => token.match(/^\d+$/));
+}
+export function deduplicateKeywordPermutations(seeds) {
+    const deduplicated = new Map();
+    const pickBetterSeed = (candidate, existing) => {
+        if (candidate.weight !== existing.weight) {
+            return candidate.weight > existing.weight ? candidate : existing;
+        }
+        const candidateWords = getSeedWordCount(candidate);
+        const existingWords = getSeedWordCount(existing);
+        if (candidateWords !== existingWords) {
+            return candidateWords < existingWords ? candidate : existing;
+        }
+        return candidate.normalizedKeyword.localeCompare(existing.normalizedKeyword) < 0
+            ? candidate
+            : existing;
+    };
+    for (const seed of seeds) {
+        const key = normalizeSeedPermutationKey(seed.normalizedKeyword);
+        const existing = deduplicated.get(key);
+        if (!existing) {
+            deduplicated.set(key, seed);
+            continue;
+        }
+        deduplicated.set(key, pickBetterSeed(seed, existing));
+    }
+    return [...deduplicated.values()];
+}
+function normalizeSeedPermutationKey(value) {
+    const normalized = normalizeKeyword(value);
+    const tokens = normalized.split(/\s+/).map((token) => token.trim()).filter(Boolean);
+    if (tokens.length === 0)
+        return '';
+    if (tokens.length === 1)
+        return tokens[0];
+    return [...tokens].sort().join(' ');
+}
+export function getSeedWordCount(seed) {
+    return seed.normalizedKeyword.split(/\s+/).filter(Boolean).length;
+}
+export function extractSchemaOrgLongTailSeeds(report, options) {
+    const items = report.structuredData?.items;
+    if (!items?.length)
+        return [];
+    const candidates = [];
+    for (const item of items) {
+        const type = (item['@type'] ?? '').toLowerCase();
+        if (type === 'faqpage') {
+            const entities = item['mainEntity'];
+            if (Array.isArray(entities)) {
+                for (const entity of entities) {
+                    const q = entity['name']?.trim();
+                    const normalized = q ? normalizeKeyword(q) : '';
+                    const words = normalized.length > 0 ? normalized.split(/\s+/).filter(Boolean).length : 0;
+                    if (q
+                        && q.length >= options.minKeywordLength
+                        && words >= 2
+                        && words <= 4) {
+                        candidates.push({ phrase: q, weight: 3.5 });
+                    }
+                }
+            }
+        }
+        if (type === 'howto') {
+            const steps = item['step'];
+            if (Array.isArray(steps)) {
+                for (const step of steps) {
+                    const s = step;
+                    const text = (s['name'] ?? s['text'])?.trim();
+                    const normalized = text ? normalizeKeyword(text) : '';
+                    const words = normalized.length > 0 ? normalized.split(/\s+/).filter(Boolean).length : 0;
+                    if (text
+                        && text.length >= options.minKeywordLength
+                        && words >= 2
+                        && words <= 4) {
+                        candidates.push({ phrase: text, weight: 2.8 });
+                    }
+                }
+            }
+        }
+        if (type === 'product') {
+            const name = item['name']?.trim();
+            if (name && name.length >= options.minKeywordLength)
+                candidates.push({ phrase: name, weight: 3.0 });
+            const category = item['category']?.trim();
+            if (category && category.length >= options.minKeywordLength)
+                candidates.push({ phrase: category, weight: 2.5 });
+            const brand = item['brand']?.['name']?.trim();
+            if (brand && brand.length >= options.minKeywordLength)
+                candidates.push({ phrase: brand, weight: 2.0 });
+        }
+        if (type === 'breadcrumblist') {
+            const elements = item['itemListElement'];
+            if (Array.isArray(elements)) {
+                const names = elements
+                    .map((el) => el['name']?.trim())
+                    .filter((n) => typeof n === 'string' && n.length >= options.minKeywordLength);
+                for (const name of names) {
+                    candidates.push({ phrase: name, weight: 2.0 });
+                }
+                for (let i = 0; i < names.length - 1; i++) {
+                    const composed = `${names[i]} ${names[i + 1]}`;
+                    if (tokenizeForLongTail(composed).length <= 5) {
+                        candidates.push({ phrase: composed, weight: 2.2 });
+                    }
+                }
+            }
+        }
+        if (type === 'article' || type === 'blogposting' || type === 'newsarticle') {
+            const headline = item['headline']?.trim();
+            if (headline && headline.length >= options.minKeywordLength)
+                candidates.push({ phrase: headline, weight: 2.8 });
+            const keywords = item['keywords'];
+            const kwList = typeof keywords === 'string'
+                ? keywords.split(/[,;]/).map((k) => k.trim()).filter(Boolean)
+                : Array.isArray(keywords)
+                    ? keywords.filter((k) => typeof k === 'string')
+                    : [];
+            for (const kw of kwList) {
+                if (kw.length >= options.minKeywordLength)
+                    candidates.push({ phrase: kw, weight: 2.5 });
+            }
+        }
+    }
+    const seen = new Set();
+    const seeds = [];
+    for (const { phrase, weight } of candidates.sort((a, b) => b.weight - a.weight)) {
+        const normalized = normalizeKeyword(phrase);
+        if (!normalized || normalized.length < options.minKeywordLength)
+            continue;
+        const words = normalized.split(/\s+/).filter(Boolean).length;
+        if (words > 4 || words < 2)
+            continue;
+        if (seen.has(normalized))
+            continue;
+        if (seeds.length >= options.maxPhrases)
+            break;
+        seen.add(normalized);
+        seeds.push({
+            keyword: phrase,
+            normalizedKeyword: normalized,
+            source: 'discovered',
+            sourcePage: options.sourcePage ? `${options.sourcePage}#schema` : undefined,
+            weight: Math.max(1, Math.round(weight * 100)),
+        });
+    }
+    return seeds;
+}
+export function extractHeadingPathCompositionSeeds(report, options) {
+    const sections = report.contentSections;
+    if (!sections?.length)
+        return [];
+    const phraseCounts = new Map();
+    const upsert = (phrase, weight) => {
+        const tokens = tokenizeForLongTail(phrase);
+        if (tokens.length < 2 || tokens.length > 4)
+            return;
+        if (isLowValueLongTail(tokens))
+            return;
+        const normalized = normalizeKeyword(tokens.join(' '));
+        if (!normalized || normalized.length < options.minKeywordLength)
+            return;
+        const current = phraseCounts.get(normalized);
+        if (!current) {
+            phraseCounts.set(normalized, { phrase: tokens.join(' '), normalized, weight });
+            return;
+        }
+        current.weight += weight * 0.5;
+    };
+    const levelWeight = (level) => level <= 1 ? 3.0 : level === 2 ? 2.2 : level === 3 ? 1.8 : 1.2;
+    for (const section of sections) {
+        const path = section.headingPath;
+        if (!path?.length)
+            continue;
+        if (section.linkDensity > 0.6)
+            continue;
+        const w = section.weight * levelWeight(section.headingLevel);
+        const pathAnchors = path.map(heading => tokenizeForLongTail(heading).filter(t => options.topKeywordSet.has(t)).slice(0, 2));
+        const activeAnchors = pathAnchors[pathAnchors.length - 1] ?? [];
+        if (pathAnchors.length >= 2) {
+            const parentAnchors = pathAnchors[pathAnchors.length - 2];
+            for (const pa of parentAnchors) {
+                for (const ca of activeAnchors) {
+                    if (pa !== ca)
+                        upsert(`${pa} ${ca}`, w);
+                }
+                if (activeAnchors.length >= 2) {
+                    upsert(`${pa} ${activeAnchors[0]} ${activeAnchors[1]}`, w * 0.9);
+                }
+            }
+        }
+        const allAnchors = pathAnchors.flat().slice(0, 4);
+        if (allAnchors.length >= 2 && new Set(allAnchors).size === allAnchors.length) {
+            upsert(allAnchors.join(' '), w * 0.85);
+        }
+        if (section.source !== 'heading' && activeAnchors.length > 0) {
+            const bodyAnchors = tokenizeForLongTail(section.text)
+                .filter(t => options.topKeywordSet.has(t) && !activeAnchors.includes(t))
+                .slice(0, 5);
+            for (const headAnchor of activeAnchors) {
+                for (const bodyAnchor of bodyAnchors) {
+                    upsert(`${headAnchor} ${bodyAnchor}`, section.weight * 1.3);
+                    const parentAnchor = pathAnchors.length >= 2 ? pathAnchors[pathAnchors.length - 2][0] : undefined;
+                    if (parentAnchor && parentAnchor !== headAnchor && parentAnchor !== bodyAnchor) {
+                        upsert(`${parentAnchor} ${headAnchor} ${bodyAnchor}`, section.weight * 1.1);
+                    }
+                }
+            }
+        }
+    }
+    return [...phraseCounts.values()]
+        .sort((a, b) => b.weight - a.weight || a.normalized.localeCompare(b.normalized))
+        .slice(0, options.maxPhrases)
+        .map((entry, index) => ({
+        keyword: entry.phrase,
+        normalizedKeyword: entry.normalized,
+        source: 'discovered',
+        sourcePage: options.sourcePage ? `${options.sourcePage}#path-${index}` : undefined,
+        weight: Math.max(1, Math.round(entry.weight * 20)),
+    }));
+}
+export function sortSeedsByWeight(a, b) {
+    if (a.weight === b.weight) {
+        return a.normalizedKeyword.localeCompare(b.normalizedKeyword);
+    }
+    return b.weight - a.weight;
+}
+export function mergeKeywordSeeds(discovered, preset, minKeywordLength = DEFAULT_SERP_MIN_KEYWORD_LENGTH, minWeight = 1) {
+    const merged = new Map();
+    const upsert = (seed) => {
+        if (!seed.normalizedKeyword || seed.normalizedKeyword.length < minKeywordLength)
+            return;
+        if (seed.weight < minWeight)
+            return;
+        const existing = merged.get(seed.normalizedKeyword);
+        if (!existing) {
+            merged.set(seed.normalizedKeyword, seed);
+            return;
+        }
+        if (existing.source === 'preset' && seed.source === 'discovered') {
+            merged.set(seed.normalizedKeyword, seed);
+            return;
+        }
+        if (seed.source === existing.source && seed.weight > existing.weight) {
+            merged.set(seed.normalizedKeyword, seed);
+        }
+    };
+    for (const seed of discovered)
+        upsert(seed);
+    for (const seed of preset)
+        upsert(seed);
+    return [...merged.values()].sort(sortSeedsByWeight);
+}

package/dist/browser/seo/keyword-campaign-seed-core.d.ts

@@ -0,0 +1,29 @@
+import type { SeoReport } from './types.js';
+import type { KeywordCampaignExtractionOptions, KeywordCampaignSeed } from './keyword-campaign-shared.js';
+export declare function extractKeywordCampaignSeedsFromReport(report: SeoReport, options?: KeywordCampaignExtractionOptions & {
+    sourcePage?: string;
+}): KeywordCampaignSeed[];
+export declare const SERP_BLOCK_CONFIDENCE = 0.6;
+export declare const SERP_CAPTCHA_CONFIDENCE = 0.6;
+export declare const DEFAULT_SERP_SEARCH_DELAY_MS = 450;
+export declare const DEFAULT_SERP_SEARCH_JITTER_MS = 250;
+export declare const DEFAULT_SERP_SEARCH_CAPTCHA_COOLDOWN_MS = 1200;
+export declare const DEFAULT_SERP_SEARCH_RETRY_COUNT = 1;
+export declare const DEFAULT_SERP_SEARCH_RETRY_DELAY_MS = 900;
+export declare const DEFAULT_SERP_MAX_CONSECUTIVE_BLOCKS = 3;
+export declare function isLikelyBlocked(block: {
+    blocked?: boolean;
+    confidence?: number;
+} | undefined): boolean;
+export declare function isLikelyCaptcha(captcha: {
+    detected?: boolean;
+    confidence?: number;
+} | undefined): boolean;
+export declare function sleep(ms: number): Promise<void>;
+export declare function buildSerpBlockReason(block: {
+    reason?: string;
+    description?: string;
+} | undefined, captcha: {
+    provider?: string;
+    description?: string;
+} | undefined): string | undefined;