untiktok-api 1.0.0

package/dist/stealth/js/utils_script.d.ts

@@ -0,0 +1 @@
+export declare const utils_script = "\nconst utils = {}\nutils.stripProxyFromErrors = (handler = {}) => {\n  const newHandler = {}\n  const traps = Object.getOwnPropertyNames(handler)\n  traps.forEach(trap => {\n    newHandler[trap] = function() {\n      try { return handler[trap].apply(this, arguments || []) } catch (err) {\n        if (!err || !err.stack || !err.stack.includes('at ')) { throw err }\n        const stripWithBlacklist = stack => {\n          const blacklist = ['at Reflect.' + trap + ' ', 'at Object.' + trap + ' ', 'at Object.newHandler.<computed> [as ' + trap + '] ']\n          return err.stack.split('\\n').filter((line, index) => index !== 1).filter(line => !blacklist.some(bl => line.trim().startsWith(bl))).join('\\n')\n        }\n        const stripWithAnchor = stack => {\n          const stackArr = stack.split('\\n')\n          const anchor = 'at Object.newHandler.<computed> [as ' + trap + '] '\n          const anchorIndex = stackArr.findIndex(line => line.trim().startsWith(anchor))\n          if (anchorIndex === -1) return false\n          stackArr.splice(1, anchorIndex)\n          return stackArr.join('\\n')\n        }\n        err.stack = stripWithAnchor(err.stack) || stripWithBlacklist(err.stack)\n        throw err\n      }\n    }\n  })\n  return newHandler\n}\nutils.stripErrorWithAnchor = (err, anchor) => {\n  const stackArr = err.stack.split('\\n')\n  const anchorIndex = stackArr.findIndex(line => line.trim().startsWith(anchor))\n  if (anchorIndex === -1) return err\n  stackArr.splice(1, anchorIndex)\n  err.stack = stackArr.join('\\n')\n  return err\n}\nutils.replaceProperty = (obj, propName, descriptorOverrides = {}) => {\n  return Object.defineProperty(obj, propName, { ...(Object.getOwnPropertyDescriptor(obj, propName) || {}), ...descriptorOverrides })\n}\nutils.preloadCache = () => {\n  if (utils.cache) return\n  utils.cache = { Reflect: { get: Reflect.get.bind(Reflect), apply: Reflect.apply.bind(Reflect) }, nativeToStringStr: Function.toString + '' }\n}\nutils.makeNativeString = (name = '') => { utils.preloadCache(); return utils.cache.nativeToStringStr.replace('toString', name || '') }\nutils.patchToString = (obj, str = '') => {\n  utils.preloadCache()\n  const toStringProxy = new Proxy(Function.prototype.toString, {\n    apply: function(target, ctx) {\n      if (ctx === Function.prototype.toString) return utils.makeNativeString('toString')\n      if (ctx === obj) return str || utils.makeNativeString(obj.name)\n      const hasSameProto = Object.getPrototypeOf(Function.prototype.toString).isPrototypeOf(ctx.toString)\n      if (!hasSameProto) return ctx.toString()\n      return target.call(ctx)\n    }\n  })\n  utils.replaceProperty(Function.prototype, 'toString', { value: toStringProxy })\n}\nutils.patchToStringNested = (obj = {}) => { return utils.execRecursively(obj, ['function'], utils.patchToString) }\nutils.redirectToString = (proxyObj, originalObj) => {\n  utils.preloadCache()\n  const toStringProxy = new Proxy(Function.prototype.toString, {\n    apply: function(target, ctx) {\n      if (ctx === Function.prototype.toString) return utils.makeNativeString('toString')\n      if (ctx === proxyObj) {\n        const fallback = () => originalObj && originalObj.name ? utils.makeNativeString(originalObj.name) : utils.makeNativeString(proxyObj.name)\n        return originalObj + '' || fallback()\n      }\n      const hasSameProto = Object.getPrototypeOf(Function.prototype.toString).isPrototypeOf(ctx.toString)\n      if (!hasSameProto) return ctx.toString()\n      return target.call(ctx)\n    }\n  })\n  utils.replaceProperty(Function.prototype, 'toString', { value: toStringProxy })\n}\nutils.replaceWithProxy = (obj, propName, handler) => {\n  utils.preloadCache()\n  const originalObj = obj[propName]\n  const proxyObj = new Proxy(obj[propName], utils.stripProxyFromErrors(handler))\n  utils.replaceProperty(obj, propName, { value: proxyObj })\n  utils.redirectToString(proxyObj, originalObj)\n  return true\n}\nutils.mockWithProxy = (obj, propName, pseudoTarget, handler) => {\n  utils.preloadCache()\n  const proxyObj = new Proxy(pseudoTarget, utils.stripProxyFromErrors(handler))\n  utils.replaceProperty(obj, propName, { value: proxyObj })\n  utils.patchToString(proxyObj)\n  return true\n}\nutils.createProxy = (pseudoTarget, handler) => {\n  utils.preloadCache()\n  const proxyObj = new Proxy(pseudoTarget, utils.stripProxyFromErrors(handler))\n  utils.patchToString(proxyObj)\n  return proxyObj\n}\nutils.splitObjPath = objPath => ({\n  objName: objPath.split('.').slice(0, -1).join('.'),\n  propName: objPath.split('.').slice(-1)[0]\n})\nutils.replaceObjPathWithProxy = (objPath, handler) => {\n  const { objName, propName } = utils.splitObjPath(objPath)\n  const obj = eval(objName)\n  return utils.replaceWithProxy(obj, propName, handler)\n}\nutils.execRecursively = (obj = {}, typeFilter = [], fn) => {\n  function recurse(obj) {\n    for (const key in obj) {\n      if (obj[key] === undefined) continue\n      if (obj[key] && typeof obj[key] === 'object') recurse(obj[key])\n      else if (obj[key] && typeFilter.includes(typeof obj[key])) fn.call(this, obj[key])\n    }\n  }\n  recurse(obj)\n  return obj\n}\n";

package/dist/stealth/js/utils_script.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils_script = void 0;
+exports.utils_script = `
+const utils = {}
+utils.stripProxyFromErrors = (handler = {}) => {
+  const newHandler = {}
+  const traps = Object.getOwnPropertyNames(handler)
+  traps.forEach(trap => {
+    newHandler[trap] = function() {
+      try { return handler[trap].apply(this, arguments || []) } catch (err) {
+        if (!err || !err.stack || !err.stack.includes('at ')) { throw err }
+        const stripWithBlacklist = stack => {
+          const blacklist = ['at Reflect.' + trap + ' ', 'at Object.' + trap + ' ', 'at Object.newHandler.<computed> [as ' + trap + '] ']
+          return err.stack.split('\\n').filter((line, index) => index !== 1).filter(line => !blacklist.some(bl => line.trim().startsWith(bl))).join('\\n')
+        }
+        const stripWithAnchor = stack => {
+          const stackArr = stack.split('\\n')
+          const anchor = 'at Object.newHandler.<computed> [as ' + trap + '] '
+          const anchorIndex = stackArr.findIndex(line => line.trim().startsWith(anchor))
+          if (anchorIndex === -1) return false
+          stackArr.splice(1, anchorIndex)
+          return stackArr.join('\\n')
+        }
+        err.stack = stripWithAnchor(err.stack) || stripWithBlacklist(err.stack)
+        throw err
+      }
+    }
+  })
+  return newHandler
+}
+utils.stripErrorWithAnchor = (err, anchor) => {
+  const stackArr = err.stack.split('\\n')
+  const anchorIndex = stackArr.findIndex(line => line.trim().startsWith(anchor))
+  if (anchorIndex === -1) return err
+  stackArr.splice(1, anchorIndex)
+  err.stack = stackArr.join('\\n')
+  return err
+}
+utils.replaceProperty = (obj, propName, descriptorOverrides = {}) => {
+  return Object.defineProperty(obj, propName, { ...(Object.getOwnPropertyDescriptor(obj, propName) || {}), ...descriptorOverrides })
+}
+utils.preloadCache = () => {
+  if (utils.cache) return
+  utils.cache = { Reflect: { get: Reflect.get.bind(Reflect), apply: Reflect.apply.bind(Reflect) }, nativeToStringStr: Function.toString + '' }
+}
+utils.makeNativeString = (name = '') => { utils.preloadCache(); return utils.cache.nativeToStringStr.replace('toString', name || '') }
+utils.patchToString = (obj, str = '') => {
+  utils.preloadCache()
+  const toStringProxy = new Proxy(Function.prototype.toString, {
+    apply: function(target, ctx) {
+      if (ctx === Function.prototype.toString) return utils.makeNativeString('toString')
+      if (ctx === obj) return str || utils.makeNativeString(obj.name)
+      const hasSameProto = Object.getPrototypeOf(Function.prototype.toString).isPrototypeOf(ctx.toString)
+      if (!hasSameProto) return ctx.toString()
+      return target.call(ctx)
+    }
+  })
+  utils.replaceProperty(Function.prototype, 'toString', { value: toStringProxy })
+}
+utils.patchToStringNested = (obj = {}) => { return utils.execRecursively(obj, ['function'], utils.patchToString) }
+utils.redirectToString = (proxyObj, originalObj) => {
+  utils.preloadCache()
+  const toStringProxy = new Proxy(Function.prototype.toString, {
+    apply: function(target, ctx) {
+      if (ctx === Function.prototype.toString) return utils.makeNativeString('toString')
+      if (ctx === proxyObj) {
+        const fallback = () => originalObj && originalObj.name ? utils.makeNativeString(originalObj.name) : utils.makeNativeString(proxyObj.name)
+        return originalObj + '' || fallback()
+      }
+      const hasSameProto = Object.getPrototypeOf(Function.prototype.toString).isPrototypeOf(ctx.toString)
+      if (!hasSameProto) return ctx.toString()
+      return target.call(ctx)
+    }
+  })
+  utils.replaceProperty(Function.prototype, 'toString', { value: toStringProxy })
+}
+utils.replaceWithProxy = (obj, propName, handler) => {
+  utils.preloadCache()
+  const originalObj = obj[propName]
+  const proxyObj = new Proxy(obj[propName], utils.stripProxyFromErrors(handler))
+  utils.replaceProperty(obj, propName, { value: proxyObj })
+  utils.redirectToString(proxyObj, originalObj)
+  return true
+}
+utils.mockWithProxy = (obj, propName, pseudoTarget, handler) => {
+  utils.preloadCache()
+  const proxyObj = new Proxy(pseudoTarget, utils.stripProxyFromErrors(handler))
+  utils.replaceProperty(obj, propName, { value: proxyObj })
+  utils.patchToString(proxyObj)
+  return true
+}
+utils.createProxy = (pseudoTarget, handler) => {
+  utils.preloadCache()
+  const proxyObj = new Proxy(pseudoTarget, utils.stripProxyFromErrors(handler))
+  utils.patchToString(proxyObj)
+  return proxyObj
+}
+utils.splitObjPath = objPath => ({
+  objName: objPath.split('.').slice(0, -1).join('.'),
+  propName: objPath.split('.').slice(-1)[0]
+})
+utils.replaceObjPathWithProxy = (objPath, handler) => {
+  const { objName, propName } = utils.splitObjPath(objPath)
+  const obj = eval(objName)
+  return utils.replaceWithProxy(obj, propName, handler)
+}
+utils.execRecursively = (obj = {}, typeFilter = [], fn) => {
+  function recurse(obj) {
+    for (const key in obj) {
+      if (obj[key] === undefined) continue
+      if (obj[key] && typeof obj[key] === 'object') recurse(obj[key])
+      else if (obj[key] && typeFilter.includes(typeof obj[key])) fn.call(this, obj[key])
+    }
+  }
+  recurse(obj)
+  return obj
+}
+`;

package/dist/stealth/js/webgl_vendor_script.d.ts

@@ -0,0 +1 @@
+export declare const webgl_vendor_script = "\nconst getParameterProxy = {\n    apply: function(target, ctx, args) {\n        const param = (args || [])[0]\n        const UNMASKED_VENDOR_WEBGL = 0x9245\n        const UNMASKED_RENDERER_WEBGL = 0x9246\n        if (param === UNMASKED_VENDOR_WEBGL) { return opts.webgl_vendor || 'Intel Inc.' }\n        if (param === UNMASKED_RENDERER_WEBGL) { return opts.webgl_renderer || 'Intel Iris OpenGL Engine' }\n        return utils.cache.Reflect.apply(target, ctx, args)\n    }\n}\nutils.replaceWithProxy(WebGLRenderingContext.prototype, 'getParameter', getParameterProxy)\n";

package/dist/stealth/js/webgl_vendor_script.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webgl_vendor_script = void 0;
+exports.webgl_vendor_script = `
+const getParameterProxy = {
+    apply: function(target, ctx, args) {
+        const param = (args || [])[0]
+        const UNMASKED_VENDOR_WEBGL = 0x9245
+        const UNMASKED_RENDERER_WEBGL = 0x9246
+        if (param === UNMASKED_VENDOR_WEBGL) { return opts.webgl_vendor || 'Intel Inc.' }
+        if (param === UNMASKED_RENDERER_WEBGL) { return opts.webgl_renderer || 'Intel Iris OpenGL Engine' }
+        return utils.cache.Reflect.apply(target, ctx, args)
+    }
+}
+utils.replaceWithProxy(WebGLRenderingContext.prototype, 'getParameter', getParameterProxy)
+`;

package/dist/stealth/js/window_outerdimensions.d.ts

@@ -0,0 +1 @@
+export declare const window_outerdimensions = "\ntry {\n    if (window.outerWidth === 0) { Object.defineProperty(window, 'outerWidth', { get: () => window.innerWidth }) }\n    if (window.outerHeight === 0) { Object.defineProperty(window, 'outerHeight', { get: () => window.innerHeight }) }\n} catch (err) { /* noop */ }\n";

package/dist/stealth/js/window_outerdimensions.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.window_outerdimensions = void 0;
+exports.window_outerdimensions = `
+try {
+    if (window.outerWidth === 0) { Object.defineProperty(window, 'outerWidth', { get: () => window.innerWidth }) }
+    if (window.outerHeight === 0) { Object.defineProperty(window, 'outerHeight', { get: () => window.innerHeight }) }
+} catch (err) { /* noop */ }
+`;

package/dist/tiktok.d.ts

@@ -0,0 +1,96 @@
+import { Browser } from "playwright";
+import type { TikTokPlaywrightSession, CreateSessionsOptions, ResourceStats, HealthCheckResult } from "./types";
+import { User, type UserOptions } from "./api/user";
+import { Video, type VideoOptions } from "./api/video";
+import { Sound, type SoundOptions } from "./api/sound";
+import { Hashtag, type HashtagOptions } from "./api/hashtag";
+import { Comment } from "./api/comment";
+import { Trending } from "./api/trending";
+import { Search } from "./api/search";
+import { Playlist, type PlaylistOptions } from "./api/playlist";
+type LogLevel = "debug" | "info" | "warn" | "error";
+export declare class Logger {
+    private level;
+    private name;
+    constructor(name: string, level?: LogLevel);
+    private _levels;
+    private _log;
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+export interface MakeRequestOptions {
+    url: string;
+    headers?: Record<string, string> | null;
+    params?: Record<string, unknown> | null;
+    retries?: number;
+    exponentialBackoff?: boolean;
+    sessionIndex?: number;
+}
+export declare class TikTokApi {
+    readonly trending: Trending;
+    readonly search: Search;
+    sessions: TikTokPlaywrightSession[];
+    browser: Browser | null;
+    playwright: {
+        stop: () => Promise<void>;
+    } | null;
+    private _sessionRecoveryEnabled;
+    private _sessionCreationLock;
+    private _cleanupCalled;
+    private _autoCleanupDeadSessions;
+    private _playwrightInstance;
+    private _userAgent;
+    readonly logger: Logger;
+    constructor(options?: {
+        loggingLevel?: LogLevel;
+        loggerName?: string;
+    });
+    user(options: UserOptions): User;
+    video(options: VideoOptions): Video;
+    sound(options: SoundOptions): Sound;
+    hashtag(options: HashtagOptions): Hashtag;
+    comment(options: {
+        data?: Record<string, unknown>;
+    }): Comment;
+    playlist(options: PlaylistOptions): Playlist;
+    private _setSessionParams;
+    _isSessionValid(session: TikTokPlaywrightSession): Promise<boolean>;
+    _markSessionInvalid(session: TikTokPlaywrightSession): Promise<void>;
+    _getValidSessionIndex(kwargs?: {
+        sessionIndex?: number;
+    }): Promise<[number, TikTokPlaywrightSession]>;
+    private _recoverSessions;
+    _getSession(kwargs?: {
+        sessionIndex?: number;
+    }): [number, TikTokPlaywrightSession];
+    createSessions(options?: CreateSessionsOptions): Promise<void>;
+    private _createSession;
+    setSessionCookies(session: TikTokPlaywrightSession, cookies: Record<string, unknown>[]): Promise<void>;
+    getSessionCookies(session: TikTokPlaywrightSession): Promise<Record<string, string>>;
+    runFetchScript(url: string, headers: Record<string, string>, kwargs?: {
+        sessionIndex?: number;
+    }): Promise<string>;
+    generateXBogus(url: string, kwargs?: {
+        sessionIndex?: number;
+    }): Promise<Record<string, string>>;
+    signUrl(url: string, kwargs?: {
+        sessionIndex?: number;
+    }): Promise<string>;
+    /**
+     * Saves the current Playwright browser context state (cookies, local storage) to a file.
+     * You can load this state back by passing \`contextOptions: { storageState: "path.json" }\` to \`createSessions\`.
+     */
+    saveSessionState(path: string, sessionIndex?: number): Promise<void>;
+    makeRequest(options: MakeRequestOptions): Promise<Record<string, unknown>>;
+    closeSessions(): Promise<void>;
+    stopPlaywright(): Promise<void>;
+    getSessionContent(url: string, kwargs?: {
+        sessionIndex?: number;
+    }): Promise<string>;
+    getResourceStats(): ResourceStats;
+    healthCheck(): Promise<HealthCheckResult>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export {};