@book000/pixivts 0.57.1 → 0.58.0

package/dist/index.cjs

@@ -257,6 +257,115 @@ function failedPaginated(error, http, getItems) {
   );
 }
 
+// src/params.ts
+function camelToSnake(key) {
+  return key.replaceAll(/([A-Z])/g, (m) => `_${m.toLowerCase()}`);
+}
+function toSnakeKeys(obj) {
+  const out = {};
+  for (const key of Object.keys(obj)) {
+    out[camelToSnake(key)] = obj[key];
+  }
+  return out;
+}
+function buildSearchParams(params) {
+  const usp = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) usp.append(`${key}[]`, String(item));
+    } else {
+      usp.set(key, String(value));
+    }
+  }
+  return usp;
+}
+function buildParams(params) {
+  return buildSearchParams(toSnakeKeys(params));
+}
+function parseNextUrl(url) {
+  const usp = new URL(url).searchParams;
+  const result = {};
+  const toNum = (key) => {
+    const v = usp.get(key);
+    if (v === null || v === "") return void 0;
+    const n = Number(v);
+    return Number.isNaN(n) ? void 0 : n;
+  };
+  const maxBookmarkId = toNum("max_bookmark_id");
+  if (maxBookmarkId !== void 0) result.maxBookmarkId = maxBookmarkId;
+  const maxBookmarkIdForRecommend = toNum("max_bookmark_id_for_recommend");
+  if (maxBookmarkIdForRecommend !== void 0)
+    result.maxBookmarkIdForRecommend = maxBookmarkIdForRecommend;
+  const minBookmarkIdForRecentIllust = toNum("min_bookmark_id_for_recent_illust");
+  if (minBookmarkIdForRecentIllust !== void 0)
+    result.minBookmarkIdForRecentIllust = minBookmarkIdForRecentIllust;
+  const offset = toNum("offset");
+  if (offset !== void 0) result.offset = offset;
+  const lastOrder = toNum("last_order");
+  if (lastOrder !== void 0) result.lastOrder = lastOrder;
+  return result;
+}
+
+// src/options.ts
+var SearchTarget = {
+  PARTIAL_MATCH_FOR_TAGS: "partial_match_for_tags",
+  EXACT_MATCH_FOR_TAGS: "exact_match_for_tags",
+  TITLE_AND_CAPTION: "title_and_caption",
+  KEYWORD: "keyword"
+};
+var SearchSort = {
+  DATE_DESC: "date_desc",
+  DATE_ASC: "date_asc",
+  POPULAR_DESC: "popular_desc"
+};
+var SearchDuration = {
+  WITHIN_LAST_DAY: "within_last_day",
+  WITHIN_LAST_WEEK: "within_last_week",
+  WITHIN_LAST_MONTH: "within_last_month"
+};
+var RankingMode = {
+  DAY: "day",
+  DAY_MALE: "day_male",
+  DAY_FEMALE: "day_female",
+  WEEK_ORIGINAL: "week_original",
+  WEEK_ROOKIE: "week_rookie",
+  WEEK: "week",
+  MONTH: "month",
+  DAY_AI: "day_ai",
+  DAY_R18: "day_r18",
+  WEEK_R18: "week_r18",
+  DAY_MALE_R18: "day_male_r18",
+  DAY_FEMALE_R18: "day_female_r18",
+  DAY_R18_AI: "day_r18_ai"
+};
+var NovelRankingMode = {
+  DAY: "day",
+  WEEK: "week",
+  DAY_MALE: "day_male",
+  DAY_FEMALE: "day_female",
+  WEEK_ROOKIE: "week_rookie",
+  DAY_R18: "day_r18",
+  WEEK_R18: "week_r18",
+  DAY_R18_AI: "day_r18_ai"
+};
+var BookmarkRestrict = {
+  PUBLIC: "public",
+  PRIVATE: "private"
+};
+var FollowRestrict = {
+  PUBLIC: "public",
+  PRIVATE: "private"
+};
+var OSFilter = {
+  FOR_IOS: "for_ios",
+  FOR_ANDROID: "for_android"
+};
+var UserIllustType = {
+  ILLUST: "illust",
+  MANGA: "manga"
+};
+
 // src/auth.ts
 var T = Array.from(
   { length: 64 },
@@ -681,33 +790,6 @@ var HttpClient = class {
   }
 };
 
-// src/params.ts
-function camelToSnake(key) {
-  return key.replaceAll(/([A-Z])/g, (m) => `_${m.toLowerCase()}`);
-}
-function toSnakeKeys(obj) {
-  const out = {};
-  for (const key of Object.keys(obj)) {
-    out[camelToSnake(key)] = obj[key];
-  }
-  return out;
-}
-function buildSearchParams(params) {
-  const usp = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === null || value === void 0) continue;
-    if (Array.isArray(value)) {
-      for (const item of value) usp.append(`${key}[]`, String(item));
-    } else {
-      usp.set(key, String(value));
-    }
-  }
-  return usp;
-}
-function buildParams(params) {
-  return buildSearchParams(toSnakeKeys(params));
-}
-
 // src/resources/illusts.ts
 var IllustResource = class {
   #http;
@@ -719,6 +801,16 @@ var IllustResource = class {
    * GET /v1/illust/detail
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * const result = await client.illusts.detail({ illustId: 12345 })
+   * if (result.isOk) {
+   *   console.log(result.value.illust.title)
+   * } else {
+   *   console.error(result.error)
+   * }
+   * ```
    */
   detail(params) {
     return this.#http.get(
@@ -751,6 +843,20 @@ var IllustResource = class {
    * GET /v1/search/illust
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * // Iterate all results across pages
+   * for await (const illust of client.illusts.search({ word: 'cat' }).items()) {
+   *   console.log(illust.title)
+   * }
+   *
+   * // Fetch only the first page
+   * const page = await client.illusts.search({ word: 'cat' })
+   * if (page.isOk) {
+   *   console.log(page.value.illusts.length)
+   * }
+   * ```
    */
   search(params) {
     return PaginatedResultAsync.fromResultAsync(
@@ -808,7 +914,9 @@ var IllustResource = class {
           includeRankingLabel: true,
           includeRankingIllusts: true,
           includePrivacyPolicy: true,
-          offset: params.offset
+          offset: params.offset,
+          maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend,
+          minBookmarkIdForRecentIllust: params.minBookmarkIdForRecentIllust
         })
       ),
       this.#http,
@@ -877,6 +985,16 @@ var NovelResource = class {
    * GET /v2/novel/detail
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * const result = await client.novels.detail({ novelId: 67890 })
+   * if (result.isOk) {
+   *   console.log(result.value.novel.title)
+   * } else {
+   *   console.error(result.error)
+   * }
+   * ```
    */
   detail(params) {
     return this.#http.get(
@@ -921,6 +1039,20 @@ var NovelResource = class {
    * GET /v1/search/novel
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * // Iterate all results across pages
+   * for await (const novel of client.novels.search({ word: 'fantasy' }).items()) {
+   *   console.log(novel.title)
+   * }
+   *
+   * // Fetch only the first page
+   * const page = await client.novels.search({ word: 'fantasy' })
+   * if (page.isOk) {
+   *   console.log(page.value.novels.length)
+   * }
+   * ```
    */
   search(params) {
     return PaginatedResultAsync.fromResultAsync(
@@ -977,7 +1109,8 @@ var NovelResource = class {
           filter: params.filter ?? "for_ios",
           includeRankingNovels: true,
           includePrivacyPolicy: true,
-          offset: params.offset
+          offset: params.offset,
+          maxBookmarkIdForRecommend: params.maxBookmarkIdForRecommend
         })
       ),
       this.#http,
@@ -1043,6 +1176,25 @@ var UserBookmarksResource = class {
    * GET /v1/user/bookmarks/illust
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * // Iterate all bookmarked illusts across pages
+   * for await (const illust of client.users.bookmarks.illusts({ userId: client.userId }).items()) {
+   *   console.log(illust.title)
+   * }
+   *
+   * // Resume from a saved cursor
+   * import { parseNextUrl } from '@book000/pixivts'
+   * const page = await client.users.bookmarks.illusts({ userId: client.userId })
+   * if (page.isOk && page.value.next_url) {
+   *   const cursor = parseNextUrl(page.value.next_url)
+   *   const next = await client.users.bookmarks.illusts({
+   *     userId: client.userId,
+   *     maxBookmarkId: cursor.maxBookmarkId,
+   *   })
+   * }
+   * ```
    */
   illusts(params) {
     return PaginatedResultAsync.fromResultAsync(
@@ -1066,6 +1218,14 @@ var UserBookmarksResource = class {
    * GET /v1/user/bookmarks/novel
    *
    * @param params - Request parameters
+   *
+   * @example
+   * ```ts
+   * // Iterate all bookmarked novels across pages
+   * for await (const novel of client.users.bookmarks.novels({ userId: client.userId }).items()) {
+   *   console.log(novel.title)
+   * }
+   * ```
    */
   novels(params) {
     return PaginatedResultAsync.fromResultAsync(
@@ -1290,12 +1450,25 @@ var PixivClient = class _PixivClient {
     this.images = new ImageResource(http);
   }
   /**
-   * Numeric user ID of the authenticated account, as a string.
+   * Numeric user ID of the authenticated account.
    *
    * Available immediately after {@link PixivClient.of} resolves.
+   * The pixiv OAuth endpoint returns the ID as a string; this getter
+   * normalises it to `number` for consistency with resource method params
+   * (e.g. `UserBookmarksIllustParams.userId`).
+   *
+   * @example
+   * ```ts
+   * const client = await PixivClient.of(refreshToken)
+   * const bookmarks = await client.users.bookmarks.illusts({ userId: client.userId })
+   * ```
    */
   get userId() {
-    return this.#auth.userId;
+    const id = Number(this.#auth.userId);
+    if (Number.isNaN(id)) {
+      throw new TypeError(`Invalid userId: "${this.#auth.userId}"`);
+    }
+    return id;
   }
   /**
    * Creates a PixivClient by refreshing the given token.
@@ -1311,14 +1484,24 @@ var PixivClient = class _PixivClient {
   }
 };
 
+exports.BookmarkRestrict = BookmarkRestrict;
+exports.FollowRestrict = FollowRestrict;
+exports.NovelRankingMode = NovelRankingMode;
+exports.OSFilter = OSFilter;
 exports.PaginatedResultAsync = PaginatedResultAsync;
 exports.PixivClient = PixivClient;
 exports.PixivFetchError = PixivFetchError;
+exports.RankingMode = RankingMode;
 exports.ResultAsync = ResultAsync;
+exports.SearchDuration = SearchDuration;
+exports.SearchSort = SearchSort;
+exports.SearchTarget = SearchTarget;
+exports.UserIllustType = UserIllustType;
 exports.apiError = apiError;
 exports.authFailedError = authFailedError;
 exports.err = err;
 exports.failedPaginated = failedPaginated;
 exports.networkError = networkError;
 exports.ok = ok;
+exports.parseNextUrl = parseNextUrl;
 exports.rateLimitError = rateLimitError;