twitter-openapi-typescript 0.0.43 → 0.0.45

package/src/api.ts

@@ -1,222 +0,0 @@
-import {
-  DefaultApiUtils,
-  InitialStateApiUtils,
-  PostApiUtils,
-  TweetApiUtils,
-  UserApiUtils,
-  UserListApiUtils,
-  V11GetApiUtils,
-  V11PostApiUtils,
-  V20GetApiUtils,
-} from '@/apis';
-import { DefaultFlag, initOverrides } from '@/models';
-import * as i from 'twitter-openapi-typescript-generated';
-import { UsersApiUtils } from './apis/usersApi';
-
-export class TwitterOpenApi {
-  static hash = '4b27150977e1bdd807de8969dc0ddd7918ac9923';
-  static url = `https://raw.githubusercontent.com/fa0311/twitter-openapi/${this.hash}/src/config/placeholder.json`;
-  static header = 'https://raw.githubusercontent.com/fa0311/latest-user-agent/refs/heads/main/header.json';
-  static twitter = 'https://x.com/home';
-  static bearer =
-    'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
-
-  static fetchApi: i.FetchAPI = fetch.bind(globalThis);
-
-  initOverrides: initOverrides = {};
-
-  setInitOverrides(initOverrides: initOverrides): void {
-    this.initOverrides = initOverrides;
-  }
-  additionalBrowserHeaders: { [key: string]: string } = {};
-
-  setAdditionalBrowserHeaders(headers: { [key: string]: string }): void {
-    this.additionalBrowserHeaders = headers;
-  }
-
-  additionalApiHeaders: { [key: string]: string } = {};
-
-  setAdditionalApiHeaders(headers: { [key: string]: string }): void {
-    this.additionalApiHeaders = headers;
-  }
-
-  async getHeaders(): Promise<{ api: { [key: string]: string }; browser: { [key: string]: string } }> {
-    const raw = await TwitterOpenApi.fetchApi(TwitterOpenApi.header, {
-      method: 'GET',
-      ...this.initOverrides,
-    });
-    const json = await raw.json();
-    const ignore = ['host', 'connection'];
-
-    const getHader = (name: string): { [key: string]: string } => {
-      return Object.entries(json[name]).reduce((a, [key, value]) => {
-        if (ignore.includes(key)) return a;
-        return { ...a, [key]: value };
-      }, {});
-    };
-
-    return {
-      api: {
-        ...getHader('chrome-fetch'),
-        'accept-encoding': 'identity',
-        pragma: 'no-cache',
-        referer: TwitterOpenApi.twitter,
-        priority: 'u=1, i',
-        'x-twitter-client-language': 'en',
-        'x-twitter-active-user': 'yes',
-        // 'x-twitter-auth-type': 'xxxx'
-        // 'x-csrf-token': 'xxxx',
-        // 'x-guest-token': 'xxxx',
-        authorization: `Bearer ${TwitterOpenApi.bearer}`,
-        ...this.additionalApiHeaders,
-      },
-      browser: {
-        ...getHader('chrome'),
-        ...this.additionalBrowserHeaders,
-      },
-    };
-  }
-
-  cookieNormalize(cookie: string[]): { [key: string]: string } {
-    return cookie.reduce((a, b) => {
-      const [key, value] = b.split('; ')[0].split('=');
-      return { ...a, [key]: value };
-    }, {});
-  }
-
-  cookieEncode(cookie: { [key: string]: string }): string {
-    return Object.entries(cookie)
-      .map(([key, value]) => `${key}=${value}`)
-      .join('; ');
-  }
-
-  setCookies(context: i.RequestContext, cookies: { [key: string]: string }): i.RequestContext {
-    if (context.init.headers) {
-      const headers = context.init.headers as i.HTTPHeaders;
-      headers['cookie'] = this.cookieEncode(cookies);
-    }
-    return context;
-  }
-
-  async getGuestClient(): Promise<TwitterOpenApiClient> {
-    let cookies: { [key: string]: string } = {};
-
-    const response = await TwitterOpenApi.fetchApi(TwitterOpenApi.twitter, {
-      method: 'GET',
-      redirect: 'manual',
-      headers: { Cookie: this.cookieEncode(cookies) },
-      ...this.initOverrides,
-    });
-
-    if (response.headers.getSetCookie) {
-      cookies = { ...cookies, ...this.cookieNormalize(response.headers.getSetCookie()) };
-    } else {
-      cookies = { ...cookies, ...this.cookieNormalize(response.headers.get('set-cookie')?.split(', ') || []) };
-    }
-    const html = await response.text();
-
-    const re = new RegExp('document.cookie="(.*?)";', 'g');
-
-    const find = [...html.matchAll(re)].map((e) => e[1]);
-    cookies = { ...cookies, ...this.cookieNormalize(find) };
-
-    cookies = Object.entries(cookies)
-      .filter(([key, value]) => key != 'ct0')
-      .reduce((a, [key, value]) => ({ ...a, [key]: value }), {});
-
-    if (!cookies['gt']) {
-      const activate_headers = { ...(await this.getHeaders()).api, cookie: this.cookieEncode(cookies) };
-      const { guest_token } = await TwitterOpenApi.fetchApi('https://api.x.com/1.1/guest/activate.json', {
-        method: 'POST',
-        headers: activate_headers,
-        ...this.initOverrides,
-      }).then((response) => response.json());
-      cookies['gt'] = guest_token;
-    }
-
-    // const chars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
-    // const csrfToken = [...Array(32)].reduce((a) => a + chars[Math.floor(Math.random() * chars.length)], '');
-    // cookies.push({ name: 'ct0', value: csrfToken });
-
-    return this.getClientFromCookies(cookies);
-  }
-
-  async getClientFromCookies(cookies: { [key: string]: string }): Promise<TwitterOpenApiClient> {
-    const api_key = (await this.getHeaders()).api;
-    if (cookies['ct0']) {
-      api_key['x-twitter-auth-type'] = 'OAuth2Session';
-      api_key['x-csrf-token'] = cookies['ct0'];
-    }
-    if (cookies['gt']) {
-      api_key['x-guest-token'] = cookies['gt'];
-    }
-
-    const config: i.ConfigurationParameters = {
-      fetchApi: TwitterOpenApi.fetchApi,
-      middleware: [{ pre: async (context) => this.setCookies(context, cookies) }],
-      apiKey: (key) => api_key[key.toLowerCase()],
-      accessToken: TwitterOpenApi.bearer,
-    };
-    return this.getClient(new i.Configuration(config));
-  }
-
-  async getClient(api: i.Configuration): Promise<TwitterOpenApiClient> {
-    const flag = (await TwitterOpenApi.fetchApi(TwitterOpenApi.url, {
-      method: 'GET',
-      ...this.initOverrides,
-    }).then((res) => res.json())) as DefaultFlag;
-    return new TwitterOpenApiClient(api, flag, this.initOverrides);
-  }
-}
-
-export class TwitterOpenApiClient {
-  config: i.Configuration;
-  flag: DefaultFlag;
-  initOverrides: initOverrides;
-
-  constructor(config: i.Configuration, flag: DefaultFlag, initOverrides: initOverrides) {
-    this.config = config;
-    this.flag = flag;
-    this.initOverrides = initOverrides;
-  }
-
-  getDefaultApi(): DefaultApiUtils {
-    return new DefaultApiUtils(new i.DefaultApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getTweetApi(): TweetApiUtils {
-    return new TweetApiUtils(new i.TweetApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getUserApi(): UserApiUtils {
-    return new UserApiUtils(new i.UserApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getUsersApi(): UsersApiUtils {
-    return new UsersApiUtils(new i.UsersApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getUserListApi(): UserListApiUtils {
-    return new UserListApiUtils(new i.UserListApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getPostApi(): PostApiUtils {
-    return new PostApiUtils(new i.PostApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getV11GetApi(): V11GetApiUtils {
-    return new V11GetApiUtils(new i.V11GetApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getV11PostApi(): V11PostApiUtils {
-    return new V11PostApiUtils(new i.V11PostApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getV20GetApi(): V20GetApiUtils {
-    return new V20GetApiUtils(new i.V20GetApi(this.config), this.flag, this.initOverrides);
-  }
-
-  getInitialStateApi(): InitialStateApiUtils {
-    return new InitialStateApiUtils();
-  }
-}

package/src/apis/defaultApi.ts

@@ -1,72 +0,0 @@
-import { DefaultFlag, RequestParam, TweetApiUtilsData, TwitterApiUtilsResponse, initOverrides } from '@/models';
-import { buildHeader, buildTweetApiUtils, errorCheck, getKwargs } from '@/utils';
-import * as i from 'twitter-openapi-typescript-generated';
-
-export type ProfileSpotlightsQueryParam = {
-  screenName: string;
-  extraParam?: { [key: string]: any };
-};
-
-export type TweetResultByRestIdParam = {
-  tweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-export class DefaultApiUtils {
-  api: i.DefaultApi;
-  flag: DefaultFlag;
-  initOverrides: initOverrides;
-
-  constructor(api: i.DefaultApi, flag: DefaultFlag, initOverrides: initOverrides) {
-    this.api = api;
-    this.flag = flag;
-    this.initOverrides = initOverrides;
-  }
-
-  async request<T1, T2>(param: RequestParam<T1, T2>): Promise<TwitterApiUtilsResponse<T1>> {
-    const apiFn: typeof param.apiFn = param.apiFn.bind(this.api);
-    const args = getKwargs(this.flag[param.key], param.param);
-    const response = await apiFn(args, this.initOverrides);
-    const checked = errorCheck(await response.value());
-    const data = param.convertFn(checked);
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: data,
-    };
-  }
-
-  async getProfileSpotlightsQuery(
-    param: ProfileSpotlightsQueryParam,
-  ): Promise<TwitterApiUtilsResponse<i.UserResultByScreenName>> {
-    const args = {
-      screenName: param.screenName,
-      ...param.extraParam,
-    };
-    const response = await this.request({
-      key: 'ProfileSpotlightsQuery',
-      apiFn: this.api.getProfileSpotlightsQueryRaw,
-      convertFn: (value) => value.data.userResultByScreenName,
-      param: args,
-    });
-
-    return response;
-  }
-
-  async getTweetResultByRestId(
-    param: TweetResultByRestIdParam,
-  ): Promise<TwitterApiUtilsResponse<TweetApiUtilsData | undefined>> {
-    const args = {
-      tweetId: param.tweetId,
-      ...param.extraParam,
-    };
-    const response = await this.request({
-      key: 'TweetResultByRestId',
-      apiFn: this.api.getTweetResultByRestIdRaw,
-      convertFn: (value) => buildTweetApiUtils({ result: value.data.tweetResult }),
-      param: args,
-    });
-
-    return response;
-  }
-}

package/src/apis/index.ts

@@ -1,10 +0,0 @@
-export { DefaultApiUtils } from './defaultApi';
-export { InitialStateApiUtils } from './initialStateApi';
-export { PostApiUtils } from './postApi';
-export { TweetApiUtils } from './tweetApi';
-export { UserApiUtils } from './userApi';
-export { UserListApiUtils } from './userListApi';
-export { UsersApiUtils } from './usersApi';
-export { V11GetApiUtils } from './v11GetApi';
-export { V11PostApiUtils } from './v11PostApi';
-export { V20GetApiUtils } from './v20GetApi';

package/src/apis/initialStateApi.ts

@@ -1,3 +0,0 @@
-export class InitialStateApiUtils {
-  // todo
-}

package/src/apis/postApi.ts

@@ -1,208 +0,0 @@
-import { DefaultFlag, TwitterApiUtilsResponse, initOverrides } from '@/models';
-import { buildHeader, errorCheck } from '@/utils';
-import * as i from 'twitter-openapi-typescript-generated';
-import { PostCreateTweetRequestVariablesToJSON } from 'twitter-openapi-typescript-generated';
-
-type PostCreateTweetParam = {
-  tweetText: string;
-  mediaIds?: string[];
-  taggedUsers?: string[][];
-  inReplyToTweetId?: string;
-  attachmentUrl?: string;
-  conversationControl?: 'Community' | 'Verified' | 'ByInvitation' | (string & {});
-  extraParam?: { [key: string]: any };
-};
-
-type PostDeleteTweetParam = {
-  tweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-type PostCreateRetweetParam = {
-  tweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-type PostDeleteRetweetParam = {
-  sourceTweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-type PostFavoriteTweetParam = {
-  tweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-type PostUnfavoriteTweetParam = {
-  tweetId: string;
-  extraParam?: { [key: string]: any };
-};
-
-export class PostApiUtils {
-  api: i.PostApi;
-  flag: DefaultFlag;
-  initOverrides: initOverrides;
-
-  constructor(api: i.PostApi, flag: DefaultFlag, initOverrides: initOverrides) {
-    this.api = api;
-    this.flag = flag;
-    this.initOverrides = initOverrides;
-  }
-
-  async postCreateTweet(param: PostCreateTweetParam): Promise<TwitterApiUtilsResponse<i.CreateTweetResponse>> {
-    const args = {
-      tweetText: param.tweetText,
-      ...param.extraParam,
-    };
-
-    const queryId = 'CreateTweet';
-    const features = i.PostCreateTweetRequestFeaturesFromJSON(this.flag[queryId]['features']);
-    const variables = i.PostCreateTweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    if (param.mediaIds) {
-      variables.media.mediaEntities = param.mediaIds!.map((mediaId, index) => ({
-        mediaId: mediaId,
-        taggedUsers: param.taggedUsers?.[index] || [],
-      }));
-    }
-
-    variables.attachmentUrl = param.attachmentUrl;
-    if (param.conversationControl) {
-      variables.conversationControl = {
-        mode: param.conversationControl,
-      };
-    }
-
-    if (param.inReplyToTweetId) {
-      variables.reply = {
-        excludeReplyUserIds: [],
-        inReplyToTweetId: param.inReplyToTweetId,
-      };
-    }
-
-    variables.disallowedReplyOptions = null as any;
-
-    const response = await this.api.postCreateTweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postCreateTweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        features: features,
-        variables: { ...variables, ...args },
-      },
-    });
-    const a = PostCreateTweetRequestVariablesToJSON(variables);
-
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-
-  async postDeleteTweet(param: PostDeleteTweetParam): Promise<TwitterApiUtilsResponse<i.DeleteTweetResponse>> {
-    const args = {
-      tweetId: param.tweetId,
-      ...param.extraParam,
-    };
-    const queryId = 'DeleteTweet';
-    const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    const response = await this.api.postDeleteTweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postDeleteTweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        variables: { ...variables, ...args },
-      },
-    });
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-
-  async postCreateRetweet(param: PostCreateRetweetParam): Promise<TwitterApiUtilsResponse<i.CreateRetweetResponse>> {
-    const args = {
-      tweetId: param.tweetId,
-      ...param.extraParam,
-    };
-    const queryId = 'CreateRetweet';
-    const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    const response = await this.api.postCreateRetweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postCreateRetweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        variables: { ...variables, ...args },
-      },
-    });
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-  async postDeleteRetweet(param: PostDeleteRetweetParam): Promise<TwitterApiUtilsResponse<i.DeleteRetweetResponse>> {
-    const args = {
-      sourceTweetId: param.sourceTweetId,
-      ...param.extraParam,
-    };
-    const queryId = 'DeleteRetweet';
-    const variables = i.PostDeleteRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    const response = await this.api.postDeleteRetweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postDeleteRetweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        variables: { ...variables, ...args },
-      },
-    });
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-
-  async postFavoriteTweet(
-    param: PostFavoriteTweetParam,
-  ): Promise<TwitterApiUtilsResponse<i.FavoriteTweetResponseData>> {
-    const args = {
-      tweetId: param.tweetId,
-      ...param.extraParam,
-    };
-    const queryId = 'FavoriteTweet';
-    const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    const response = await this.api.postFavoriteTweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postFavoriteTweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        variables: { ...variables, ...args },
-      },
-    });
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-
-  async postUnfavoriteTweet(
-    param: PostUnfavoriteTweetParam,
-  ): Promise<TwitterApiUtilsResponse<i.UnfavoriteTweetResponseData>> {
-    const args = {
-      tweetId: param.tweetId,
-      ...param.extraParam,
-    };
-    const queryId = 'UnfavoriteTweet';
-    const variables = i.PostCreateRetweetRequestVariablesFromJSON(this.flag[queryId]['variables']);
-    const response = await this.api.postUnfavoriteTweetRaw({
-      pathQueryId: this.flag[queryId]['queryId'],
-      postUnfavoriteTweetRequest: {
-        queryId: this.flag[queryId]['queryId'],
-        variables: { ...variables, ...args },
-      },
-    });
-    return {
-      raw: { response: response.raw },
-      header: buildHeader(response.raw.headers),
-      data: errorCheck(await response.value()),
-    };
-  }
-}