@optable/web-sdk 0.45.0 → 0.49.0

package/lib/dist/core/context.js

@@ -0,0 +1,146 @@
+const DEFAULT_MAX_CONTENT_LENGTH = 5000;
+const DEFAULT_MAX_HTML_LENGTH = 50000;
+const MAX_HEADINGS = 20;
+function extractSemanticContent(config) {
+    var _a;
+    const semantic = {
+        title: document.title || "",
+    };
+    // Extract meta description
+    const descriptionMeta = document.querySelector('meta[name="description"]');
+    if (descriptionMeta) {
+        const content = descriptionMeta.getAttribute("content");
+        if (content) {
+            semantic.description = content;
+        }
+    }
+    // Extract meta keywords
+    const keywordsMeta = document.querySelector('meta[name="keywords"]');
+    if (keywordsMeta) {
+        const content = keywordsMeta.getAttribute("content");
+        if (content) {
+            semantic.keywords = content
+                .split(",")
+                .map((k) => k.trim())
+                .filter(Boolean);
+        }
+    }
+    // Extract canonical URL
+    const canonicalLink = document.querySelector('link[rel="canonical"]');
+    if (canonicalLink) {
+        const href = canonicalLink.getAttribute("href");
+        if (href) {
+            semantic.canonicalUrl = href;
+        }
+    }
+    // Extract Open Graph tags
+    const ogTags = {};
+    document.querySelectorAll('meta[property^="og:"]').forEach((meta) => {
+        const property = meta.getAttribute("property");
+        const content = meta.getAttribute("content");
+        if (property && content) {
+            const key = property.replace("og:", "");
+            ogTags[key] = content;
+        }
+    });
+    if (Object.keys(ogTags).length > 0) {
+        semantic.ogTags = ogTags;
+    }
+    // Extract headings (h1-h3, max 20)
+    const headings = [];
+    document.querySelectorAll("h1, h2, h3").forEach((heading) => {
+        var _a;
+        if (headings.length >= MAX_HEADINGS)
+            return;
+        const level = parseInt(heading.tagName.substring(1), 10);
+        const text = (_a = heading.textContent) === null || _a === void 0 ? void 0 : _a.trim();
+        if (text) {
+            headings.push({ level, text });
+        }
+    });
+    if (headings.length > 0) {
+        semantic.headings = headings;
+    }
+    // Extract main content
+    const maxContentLength = (_a = config.maxContentLength) !== null && _a !== void 0 ? _a : DEFAULT_MAX_CONTENT_LENGTH;
+    const contentElement = findContentElement(config.contentSelector);
+    if (contentElement) {
+        const text = extractTextContent(contentElement);
+        if (text) {
+            semantic.content = text.substring(0, maxContentLength);
+        }
+    }
+    // Extract JSON-LD
+    const jsonLdScripts = document.querySelectorAll('script[type="application/ld+json"]');
+    const jsonLdData = [];
+    jsonLdScripts.forEach((script) => {
+        try {
+            const data = JSON.parse(script.textContent || "");
+            if (data && typeof data === "object") {
+                jsonLdData.push(data);
+            }
+        }
+        catch (_a) {
+            // Ignore invalid JSON-LD
+        }
+    });
+    if (jsonLdData.length > 0) {
+        semantic.jsonLd = jsonLdData;
+    }
+    // Extract language
+    const lang = document.documentElement.getAttribute("lang");
+    if (lang) {
+        semantic.language = lang;
+    }
+    return semantic;
+}
+function findContentElement(selector) {
+    // Use provided selector if available
+    if (selector) {
+        return document.querySelector(selector);
+    }
+    // Fall back to heuristics: main, article, or first large content block
+    const candidates = ["main", "article", '[role="main"]', ".content", "#content", ".post", ".article"];
+    for (const candidate of candidates) {
+        const element = document.querySelector(candidate);
+        if (element) {
+            return element;
+        }
+    }
+    // Last resort: body
+    return document.body;
+}
+function extractTextContent(element) {
+    if (element instanceof HTMLElement && element.innerText) {
+        return element.innerText.trim();
+    }
+    return "";
+}
+function extractContext(config) {
+    var _a;
+    const contextData = {
+        semantic: extractSemanticContent(config),
+        url: window.location.href,
+        extractedAt: Date.now(),
+    };
+    // Include referrer if available
+    if (document.referrer) {
+        contextData.referrer = document.referrer;
+    }
+    // Include HTML if configured
+    if (config.includeHtml) {
+        const maxHtmlLength = (_a = config.maxHtmlLength) !== null && _a !== void 0 ? _a : DEFAULT_MAX_HTML_LENGTH;
+        contextData.html = document.documentElement.outerHTML.substring(0, maxHtmlLength);
+    }
+    return contextData;
+}
+function normalizeContextConfig(config) {
+    if (!config) {
+        return null;
+    }
+    if (config === true) {
+        return {};
+    }
+    return config;
+}
+export { extractContext, extractSemanticContent, normalizeContextConfig };

package/lib/dist/core/storage.d.ts

@@ -12,6 +12,7 @@ declare class LocalStorage {
     constructor(config: ResolvedConfig);
     getPassport(): string | null;
     setPassport(passport: string): void;
+    getVisitorId(): string | null;
     getTargeting(): TargetingResponse | null;
     setTargeting(targeting?: TargetingResponse | null): void;
     getSite(): SiteResponse | null;

package/lib/dist/core/storage.js

@@ -16,6 +16,26 @@ class LocalStorage {
     setPassport(passport) {
         this.writeToStorageKeys(this.passportKeys, passport);
     }
+    getVisitorId() {
+        const passport = this.getPassport();
+        if (!passport)
+            return null;
+        const payload = passport.split(".")[1];
+        if (!payload)
+            return null;
+        try {
+            // JWT payload is base64url; normalize to base64 before atob.
+            const b64 = payload
+                .replace(/-/g, "+")
+                .replace(/_/g, "/")
+                .padEnd(payload.length + ((4 - (payload.length % 4)) % 4), "=");
+            const claims = JSON.parse(atob(b64));
+            return typeof (claims === null || claims === void 0 ? void 0 : claims.id) === "string" ? claims.id : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     getTargeting() {
         const raw = this.readStorageKeys(this.targetingKeys);
         return raw ? JSON.parse(raw) : null;

package/lib/dist/edge/targeting.js

@@ -52,6 +52,9 @@ function Targeting(config, req) {
             if (abTest.skipMatchers) {
                 searchParams.append("skip_matchers", abTest.skipMatchers.join(","));
             }
+            if (abTest.skipResolvers) {
+                searchParams.append("skip_resolvers", abTest.skipResolvers.join(","));
+            }
         }
         if ((_a = config.additionalTargetingSignals) === null || _a === void 0 ? void 0 : _a.ref) {
             searchParams.append("ref", `${window.location.protocol}//${window.location.host}${window.location.pathname}`);

package/lib/dist/edge/witness.d.ts

@@ -1,7 +1,10 @@
 import type { ResolvedConfig } from "../config";
+import type { ContextData } from "../core/context";
 type WitnessProperties = {
-    [key: string]: string | number | boolean;
+    [key: string]: string | number | boolean | unknown[] | null | {
+        [key: string]: unknown;
+    };
 };
-declare function Witness(config: ResolvedConfig, event: string, properties: WitnessProperties): Promise<void>;
+declare function Witness(config: ResolvedConfig, event: string, properties: WitnessProperties, context?: ContextData): Promise<void>;
 export { Witness, WitnessProperties };
 export default Witness;

package/lib/dist/edge/witness.js

@@ -1,9 +1,12 @@
 import { fetch } from "../core/network";
-function Witness(config, event, properties) {
+function Witness(config, event, properties, context) {
     const evt = {
         event: event,
         properties: properties,
     };
+    if (context) {
+        evt.pageContext = context;
+    }
     return fetch("/witness", config, {
         method: "POST",
         headers: {

package/lib/dist/sdk.d.ts

@@ -10,6 +10,10 @@ declare class OptableSDK {
     static version: string;
     dcn: ResolvedConfig;
     protected init: Promise<void>;
+    private contextSent;
+    private contextConfig;
+    private passportNullWarned;
+    private visitorIdNullWarned;
     constructor(dcn: InitConfig);
     initialize(): Promise<void>;
     identify(...ids: string[]): Promise<void>;
@@ -18,12 +22,17 @@ declare class OptableSDK {
     targetingFromCache(): TargetingResponse | null;
     site(): Promise<SiteResponse>;
     siteFromCache(): SiteResponse | null;
+    passport(): string | null;
+    visitorId(): string | null;
     targetingClearCache(): void;
     prebidORTB2(): Promise<PrebidORTB2>;
     prebidORTB2FromCache(): PrebidORTB2;
     targetingKeyValues(): Promise<TargetingKeyValues>;
     targetingKeyValuesFromCache(): TargetingKeyValues;
-    witness(event: string, properties?: WitnessProperties): Promise<void>;
+    witness(event: string, properties?: WitnessProperties, options?: {
+        includeContext?: boolean;
+    }): Promise<void>;
+    resetContext(): void;
     profile(traits: ProfileTraits, id?: string | null, neighbors?: string[] | null): Promise<void>;
     tokenize(id: string): Promise<TokenizeResponse>;
     resolve(id?: string): Promise<ResolveResponse>;

package/lib/dist/sdk.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { default as buildInfo } from "./build.json";
 import { getConfig } from "./config";
+import { extractContext, normalizeContextConfig } from "./core/context";
 import { Identify } from "./edge/identify";
 import { Uid2Token } from "./edge/uid2_token";
 import { Resolve } from "./edge/resolve";
@@ -19,9 +20,15 @@ import { Witness } from "./edge/witness";
 import { Profile } from "./edge/profile";
 import { sha256 } from "js-sha256";
 import { Tokenize } from "./edge/tokenize";
+import { LocalStorage } from "./core/storage";
 class OptableSDK {
     constructor(dcn) {
+        this.contextSent = false;
+        this.contextConfig = null;
+        this.passportNullWarned = false;
+        this.visitorIdNullWarned = false;
         this.dcn = getConfig(dcn);
+        this.contextConfig = normalizeContextConfig(dcn.pageContext);
         this.init = this.initialize();
     }
     initialize() {
@@ -64,6 +71,26 @@ class OptableSDK {
     siteFromCache() {
         return SiteFromCache(this.dcn);
     }
+    passport() {
+        const value = new LocalStorage(this.dcn).getPassport();
+        if (value === null && !this.passportNullWarned) {
+            this.passportNullWarned = true;
+            console.warn("[Optable] passport() returned null. The passport is cached in localStorage once the DCN returns one. " +
+                "Call before initialization (await sdk.site() or sdk.targeting()) may return null, and deployments where the DCN " +
+                "does not echo the passport in response bodies will never populate it client-side.");
+        }
+        return value;
+    }
+    visitorId() {
+        const value = new LocalStorage(this.dcn).getVisitorId();
+        if (value === null && !this.visitorIdNullWarned) {
+            this.visitorIdNullWarned = true;
+            console.warn("[Optable] visitorId() returned null. The visitor ID is derived from the passport JWT in localStorage. " +
+                "Call before initialization (await sdk.site() or sdk.targeting()) may return null, and deployments where the DCN " +
+                "does not echo the passport in response bodies will never populate it client-side.");
+        }
+        return value;
+    }
     targetingClearCache() {
         TargetingClearCache(this.dcn);
     }
@@ -86,11 +113,19 @@ class OptableSDK {
         return TargetingKeyValues(tdata);
     }
     witness(event_1) {
-        return __awaiter(this, arguments, void 0, function* (event, properties = {}) {
+        return __awaiter(this, arguments, void 0, function* (event, properties = {}, options = {}) {
             yield this.init;
-            return Witness(this.dcn, event, properties);
+            let context;
+            if (options.includeContext && this.contextConfig && !this.contextSent) {
+                context = extractContext(this.contextConfig);
+                this.contextSent = true;
+            }
+            return Witness(this.dcn, event, properties, context);
         });
     }
+    resetContext() {
+        this.contextSent = false;
+    }
     profile(traits_1) {
         return __awaiter(this, arguments, void 0, function* (traits, id = null, neighbors = null) {
             yield this.init;

package/package.json

@@ -5,11 +5,11 @@
   "browser": "./lib/dist/sdk.js",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/optable/optable-web-sdk.git"
+    "url": "git+https://github.com/Optable/optable-web-sdk.git"
   },
   "homepage": "https://optable.co",
   "license": "SEE LICENSE IN LICENSE",
-  "version": "v0.45.0",
+  "version": "v0.49.0",
   "devDependencies": {
     "@babel/core": "^7.12.3",
     "@babel/plugin-proposal-class-properties": "^7.12.1",
@@ -18,6 +18,7 @@
     "@babel/preset-typescript": "^7.12.1",
     "@types/googletag": "^3.1.3",
     "@types/jest": "^26.0.15",
+    "@types/node": "^25.0.3",
     "babel-jest": "^29.7.0",
     "babel-loader": "^8.2.2",
     "core-js": "^3.7.0",
@@ -28,13 +29,15 @@
     "prettier": "^3.6.2",
     "shellcheck": "^3.0.0",
     "typescript": "^5.2.2",
-    "webpack": "^5.97.1",
+    "webpack": "^5.104.1",
     "webpack-cli": "^5.1.4",
     "whatwg-fetch": "^3.6.20"
   },
   "dependencies": {
     "@babel/runtime": "^7.27.0",
     "@optable/web-sdk": "^0.40.0",
+    "bowser": "^2.12.1",
+    "iab-adcom": "^1.0.6",
     "iab-openrtb": "^1.0.1",
     "js-sha256": "^0.11.0",
     "regenerator-runtime": "^0.13.7"
@@ -47,12 +50,12 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "npm run build-lib && npm run build-web",
+    "build": "pnpm build-lib && pnpm build-web",
     "start": "tsc -b browser --watch & webpack --config=./browser/webpack.config.js --mode=development --watch --devtool=source-map",
     "build-lib": "tsc -b lib",
     "build-web": "tsc -b browser && webpack --config=./browser/webpack.config.js",
     "test": "jest",
     "format": "prettier . --write",
-    "lint-scripts": "npx shellcheck scripts/*.sh"
+    "lint-scripts": "pnpm exec shellcheck scripts/*.sh"
   }
-}
+}