e621-client 1.0.0

package/.README

@@ -0,0 +1,47 @@
+# e621 Client
+
+This is a small client to do some stuff with the e621 API. It is created to fit my needs, but you can use it too, if it works for you.
+
+I can't guarantee it will work in the future, so I recommend you just use another package instead or build a client yourself.
+
+### Supported Endpoints
+
+- `/favorites`
+- `/users`
+- `/users/:id`
+- `/posts`
+- `/posts/:id`
+
+### Getting Started
+
+Just create an instance of the client like so:
+
+```ts
+const client = new E621ApiClient({
+  client: "Your client name",
+  isBrowser: false,
+});
+```
+
+Now you can use it to do some stuff:
+
+```ts
+// not useful but still here (like me)
+const posts = await client.getPosts();
+
+// search posts by tags
+const postsWithTags = await client.getPosts({
+  tags: "male score:>100",
+});
+
+// search users by names (_ for wildcards)
+const toms = await client.getUsers({
+  nameMatches: "tom_",
+});
+
+// if you have credentials set, they will be sent with your requests as well:
+client.setCredentials({
+  username: "HornyFurry",
+  apiKey: "wouldntyouliketoknowweatherboy",
+});
+```

package/dist/client/E621ApiClient.d.ts

@@ -0,0 +1,49 @@
+import { E621Post } from "../types/e621/E621Post";
+import { E621User } from "../types/e621/E621User";
+import { E621ApiHeaders } from "./E621ApiHeaders";
+export interface E621ApiOptions {
+    client: string;
+    isBrowser: boolean;
+    credentials?: Credentials;
+}
+export type GetOptions = {
+    route: Route;
+    params?: Params;
+    headers?: E621ApiHeaders;
+};
+export interface Credentials {
+    username: string;
+    apiKey: string;
+}
+export type EntityId = string | number;
+export type Route = string | number | (string | number)[];
+export type Params = Record<string, string>;
+export type Pagination = {
+    limit?: string;
+    page?: string;
+};
+export type GetUsersOptions = {
+    nameMatches?: string;
+} & Params & Pagination;
+export type GetPostsOptions = {
+    tags?: string;
+} & Pagination;
+export type GetFavoritesOptions = {
+    userId?: string;
+} & Pagination;
+export declare class E621ApiClient {
+    protected static readonly BASE_URL = "https://e621.net/";
+    private readonly client;
+    private readonly isBrowser;
+    private credentials;
+    constructor(options: E621ApiOptions);
+    getUsers(options?: GetUsersOptions): Promise<E621User[]>;
+    getUserById(id: EntityId): Promise<E621User | null>;
+    getPosts(options?: GetPostsOptions): Promise<E621Post[]>;
+    getPostById(id: EntityId): Promise<E621Post | null>;
+    getFavorites(options?: GetFavoritesOptions): Promise<E621Post[]>;
+    setCredentials(credentials: Credentials | null): E621ApiClient;
+    checkCredentials(credentials?: Credentials): Promise<boolean>;
+    get<E>({ route, params, headers, }: GetOptions): Promise<E | null>;
+    private buildUrl;
+}

package/dist/client/E621ApiClient.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E621ApiClient = void 0;
+const E621Post_1 = require("../types/e621/E621Post");
+const E621User_1 = require("../types/e621/E621User");
+const utils_1 = require("../utils");
+const E621ApiHeaders_1 = require("./E621ApiHeaders");
+class E621ApiClient {
+    constructor(options) {
+        this.credentials = null;
+        this.client = options.client;
+        this.isBrowser = options.isBrowser;
+        this.credentials = options.credentials || null;
+    }
+    // Users
+    getUsers() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const users = yield this.get({
+                route: "users",
+                params: (0, utils_1.translateOptions)(options, {
+                    nameMatches: "search[name_matches]",
+                }),
+            });
+            return (users === null || users === void 0 ? void 0 : users.map(E621User_1.parseUser)) || [];
+        });
+    }
+    getUserById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.get({ route: ["users", id] });
+            return user ? (0, E621User_1.parseUser)(user) : null;
+        });
+    }
+    // Posts
+    getPosts() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const response = yield this.get({
+                route: "posts",
+                params: options,
+            });
+            return (response === null || response === void 0 ? void 0 : response.posts.map(E621Post_1.parsePost)) || [];
+        });
+    }
+    getPostById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.get({ route: ["posts", id] });
+            return (response === null || response === void 0 ? void 0 : response.post) ? (0, E621Post_1.parsePost)(response.post) : null;
+        });
+    }
+    // Favorites
+    getFavorites() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a;
+            const response = yield this.get({
+                route: "favorites",
+                params: (0, utils_1.translateOptions)(options, { userId: "user_id" }),
+            });
+            return ((_a = response === null || response === void 0 ? void 0 : response.posts) === null || _a === void 0 ? void 0 : _a.map(E621Post_1.parsePost)) || [];
+        });
+    }
+    // Account
+    setCredentials(credentials) {
+        this.credentials = credentials;
+        return this;
+    }
+    checkCredentials(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (credentials) {
+                this.setCredentials(credentials);
+            }
+            const headers = new E621ApiHeaders_1.E621ApiHeaders();
+            if (!this.isBrowser) {
+                headers.addUserAgent(this.client);
+            }
+            return yield fetch(this.buildUrl("favorites"), {
+                headers: headers.addAuthorization(this.credentials).build(),
+            })
+                .then((res) => res.ok)
+                .catch(() => false);
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ route, params, headers = new E621ApiHeaders_1.E621ApiHeaders(), }) {
+            if (!this.isBrowser) {
+                headers.addUserAgent(this.client);
+            }
+            const response = yield fetch(this.buildUrl(route, params), {
+                method: "GET",
+                headers: headers.addAuthorization(this.credentials).build(),
+            });
+            return response.json().catch(() => null);
+        });
+    }
+    buildUrl(route, params = {}) {
+        const queryParams = new URLSearchParams(params);
+        const url = E621ApiClient.BASE_URL + (0, utils_1.ensureArray)(route).join("/") + ".json";
+        if (this.isBrowser) {
+            queryParams.set("_client", this.client);
+        }
+        return queryParams.size > 0 ? `${url}?${queryParams}` : url;
+    }
+}
+exports.E621ApiClient = E621ApiClient;
+E621ApiClient.BASE_URL = "https://e621.net/";

package/dist/client/E621ApiHeaders.d.ts

@@ -0,0 +1,10 @@
+import { Credentials } from "./E621ApiClient";
+export declare class E621ApiHeaders {
+    private readonly value;
+    constructor(value?: Record<string, string>);
+    addAuthorization(credentials: Credentials | null): E621ApiHeaders;
+    addFormContentType(): E621ApiHeaders;
+    addUserAgent(userAgent: string): E621ApiHeaders;
+    build(): Record<string, string>;
+    protected static buildAuthorization({ username, apiKey }: Credentials): string;
+}

package/dist/client/E621ApiHeaders.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E621ApiHeaders = void 0;
+class E621ApiHeaders {
+    constructor(value = {}) {
+        this.value = value;
+    }
+    addAuthorization(credentials) {
+        if (credentials) {
+            this.value.Authorization = E621ApiHeaders.buildAuthorization(credentials);
+        }
+        return this;
+    }
+    addFormContentType() {
+        this.value["Content-Type"] =
+            "application/x-www-form-urlencoded; charset=UTF-8";
+        return this;
+    }
+    addUserAgent(userAgent) {
+        this.value["User-Agent"] = userAgent;
+        return this;
+    }
+    build() {
+        return this.value;
+    }
+    static buildAuthorization({ username, apiKey }) {
+        const creds = `${username}:${apiKey}`;
+        if (canUseWindow()) {
+            return `Basic ${window.btoa(creds)}`;
+        }
+        else if (canUseBuffer()) {
+            return `Basic ${Buffer.from(creds).toString("base64")}`;
+        }
+        else {
+            throw new Error("Environment does not support base64 encoding");
+        }
+    }
+}
+exports.E621ApiHeaders = E621ApiHeaders;
+function canUseWindow() {
+    return typeof window !== "undefined";
+}
+function canUseBuffer() {
+    return typeof Buffer !== "undefined" && typeof Buffer.from === "function";
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client/E621ApiClient";
+export * from "./types/e621/E621User";
+export * from "./types/e621/E621Post";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/E621ApiClient"), exports);
+__exportStar(require("./types/e621/E621User"), exports);
+__exportStar(require("./types/e621/E621Post"), exports);

package/dist/types/e621/E621Post.d.ts

@@ -0,0 +1,133 @@
+export interface PostResponse {
+    id: number;
+    created_at: string;
+    updated_at: string;
+    file: {
+        width: number;
+        height: number;
+        ext: string;
+        size: number;
+        md5: string;
+        url: string;
+    };
+    preview: {
+        width: number;
+        height: number;
+        url: string | null;
+    };
+    sample: {
+        has: boolean;
+        width: number;
+        height: number;
+        url: string | null;
+    };
+    score: {
+        up: number;
+        down: number;
+        total: number;
+    };
+    tags: {
+        general: string[];
+        artist: string[];
+        copyright: string[];
+        character: string[];
+        species: string[];
+        invalid: string[];
+        meta: string[];
+        lore: string[];
+    };
+    locked_tags: string[];
+    change_seq: number;
+    flags: {
+        pending: boolean;
+        flagged: boolean;
+        note_locked: boolean;
+        status_locked: boolean;
+        rating_locked: boolean;
+        deleted: boolean;
+    };
+    rating: string;
+    fav_count: number;
+    sources: string[];
+    pools: number[];
+    relationships: {
+        parent_id: number | null;
+        has_children: boolean;
+        has_active_children: boolean;
+        children: number[];
+    };
+    approver_id: number | null;
+    uploader_id: number;
+    description: string;
+    comment_count: number;
+    is_favorited: boolean;
+    has_notes: boolean;
+    duration: number | null;
+}
+export interface E621Post {
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    file: {
+        width: number;
+        height: number;
+        ext: string;
+        size: number;
+        md5: string;
+        url: string;
+    };
+    preview: {
+        width: number;
+        height: number;
+        url: string | null;
+    };
+    sample: {
+        has: boolean;
+        width: number;
+        height: number;
+        url: string | null;
+    };
+    score: {
+        up: number;
+        down: number;
+        total: number;
+    };
+    tags: {
+        general: string[];
+        artist: string[];
+        copyright: string[];
+        character: string[];
+        species: string[];
+        invalid: string[];
+        meta: string[];
+        lore: string[];
+    };
+    lockedTags: string[];
+    changeSeq: number;
+    flags: {
+        pending: boolean;
+        flagged: boolean;
+        noteLocked: boolean;
+        statusLocked: boolean;
+        ratingLocked: boolean;
+        deleted: boolean;
+    };
+    rating: string;
+    favCount: number;
+    sources: string[];
+    pools: number[];
+    relationships: {
+        parentId: number | null;
+        hasChildren: boolean;
+        hasActiveChildren: boolean;
+        children: number[];
+    };
+    approverId: number | null;
+    uploaderId: number;
+    description: string;
+    commentCount: number;
+    isFavorited: boolean;
+    hasNotes: boolean;
+    duration: number | null;
+}
+export declare function parsePost(post: PostResponse): E621Post;

package/dist/types/e621/E621Post.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePost = void 0;
+function parsePost(post) {
+    return {
+        id: post.id,
+        createdAt: new Date(post.created_at),
+        updatedAt: new Date(post.updated_at),
+        file: post.file,
+        preview: post.preview,
+        sample: post.sample,
+        score: post.score,
+        tags: post.tags,
+        lockedTags: post.locked_tags,
+        changeSeq: post.change_seq,
+        flags: {
+            pending: post.flags.pending,
+            flagged: post.flags.flagged,
+            noteLocked: post.flags.note_locked,
+            statusLocked: post.flags.status_locked,
+            ratingLocked: post.flags.rating_locked,
+            deleted: post.flags.deleted,
+        },
+        rating: post.rating,
+        favCount: post.fav_count,
+        sources: post.sources,
+        pools: post.pools,
+        relationships: {
+            parentId: post.relationships.parent_id,
+            hasChildren: post.relationships.has_children,
+            hasActiveChildren: post.relationships.has_active_children,
+            children: post.relationships.children,
+        },
+        approverId: post.approver_id,
+        uploaderId: post.uploader_id,
+        description: post.description,
+        commentCount: post.comment_count,
+        isFavorited: post.is_favorited,
+        hasNotes: post.has_notes,
+        duration: post.duration,
+    };
+}
+exports.parsePost = parsePost;

package/dist/types/e621/E621User.d.ts

@@ -0,0 +1,63 @@
+export interface UserResponse {
+    wiki_page_version_count: number;
+    artist_version_count: number;
+    pool_version_count: number;
+    forum_post_count: number;
+    comment_count: number;
+    flag_count: number;
+    favorite_count: number;
+    positive_feedback_count: number;
+    neutral_feedback_count: number;
+    negative_feedback_count: number;
+    upload_limit: number;
+    profile_about: string;
+    profile_artinfo: string;
+    id: number;
+    created_at: string;
+    name: string;
+    level: number;
+    base_upload_limit: number;
+    post_upload_count: number;
+    post_update_count: number;
+    note_update_count: number;
+    is_banned: boolean;
+    can_approve_posts: boolean;
+    can_upload_free: boolean;
+    level_string: string;
+    avatar_id: number | null;
+}
+export interface E621User {
+    id: number;
+    profile: {
+        name: string;
+        level: number;
+        about: string;
+        artInfo: string;
+        avatarId: number | null;
+        createdAt: Date;
+        levelString: string;
+    };
+    counts: {
+        wikiPageVersion: number;
+        artistVersion: number;
+        poolVersion: number;
+        forumPost: number;
+        comment: number;
+        flag: number;
+        favorite: number;
+        positiveFeedback: number;
+        neutralFeedback: number;
+        negativeFeedback: number;
+    };
+    limits: {
+        upload: number;
+        baseUpload: number;
+        postUpload: number;
+        postUpdate: number;
+        noteUpdate: number;
+    };
+    isBanned: boolean;
+    canApprovePosts: boolean;
+    canUploadFree: boolean;
+}
+export declare function parseUser(user: UserResponse): E621User;

package/dist/types/e621/E621User.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUser = void 0;
+function parseUser(user) {
+    return {
+        id: user.id,
+        profile: {
+            name: user.name,
+            level: user.level,
+            about: user.profile_about,
+            artInfo: user.profile_artinfo,
+            avatarId: user.avatar_id,
+            createdAt: new Date(user.created_at),
+            levelString: user.level_string,
+        },
+        counts: {
+            wikiPageVersion: user.wiki_page_version_count,
+            artistVersion: user.artist_version_count,
+            poolVersion: user.pool_version_count,
+            forumPost: user.forum_post_count,
+            comment: user.comment_count,
+            flag: user.flag_count,
+            favorite: user.favorite_count,
+            positiveFeedback: user.positive_feedback_count,
+            neutralFeedback: user.neutral_feedback_count,
+            negativeFeedback: user.negative_feedback_count,
+        },
+        limits: {
+            upload: user.upload_limit,
+            baseUpload: user.base_upload_limit,
+            postUpload: user.post_upload_count,
+            postUpdate: user.post_update_count,
+            noteUpdate: user.note_update_count,
+        },
+        isBanned: user.is_banned,
+        canApprovePosts: user.can_approve_posts,
+        canUploadFree: user.can_upload_free,
+    };
+}
+exports.parseUser = parseUser;

package/dist/types/responses.d.ts

@@ -0,0 +1,10 @@
+import { PostResponse } from "./e621/E621Post";
+export type GetFavoritesResponse = {
+    posts: PostResponse[] | null;
+};
+export type GetPostResponse = {
+    post: PostResponse | null;
+};
+export type GetPostsResponse = {
+    posts: PostResponse[];
+};

package/dist/types/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureArray<T>(value: T | T[]): T[];
+export declare function translateOptions<Options extends Record<string, string>>(options: Options, table: Partial<Options>): Record<string, string>;

package/dist/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateOptions = exports.ensureArray = void 0;
+function ensureArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+}
+exports.ensureArray = ensureArray;
+function translateOptions(options, table) {
+    var _a;
+    const params = {};
+    for (const [key, value] of Object.entries(options)) {
+        params[(_a = table[key]) !== null && _a !== void 0 ? _a : key] = value;
+    }
+    return params;
+}
+exports.translateOptions = translateOptions;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "e621-client",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "Tommus",
+  "license": "ISC",
+  "description": "A simple client for the e621 API",
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "prettier": "^3.3.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}

package/src/client/E621ApiClient.ts

@@ -0,0 +1,140 @@
+import { E621Post, parsePost } from "../types/e621/E621Post";
+import { E621User, UserResponse, parseUser } from "../types/e621/E621User";
+import {
+  GetFavoritesResponse,
+  GetPostResponse,
+  GetPostsResponse,
+} from "../types/responses";
+import { ensureArray, translateOptions } from "../utils";
+import { E621ApiHeaders } from "./E621ApiHeaders";
+
+export interface E621ApiOptions {
+  client: string;
+  isBrowser: boolean;
+  credentials?: Credentials;
+}
+
+export type GetOptions = {
+  route: Route;
+  params?: Params;
+  headers?: E621ApiHeaders;
+};
+
+export interface Credentials {
+  username: string;
+  apiKey: string;
+}
+
+export type EntityId = string | number;
+export type Route = string | number | (string | number)[];
+export type Params = Record<string, string>;
+export type Pagination = { limit?: string; page?: string };
+
+export type GetUsersOptions = { nameMatches?: string } & Params & Pagination;
+export type GetPostsOptions = { tags?: string } & Pagination;
+export type GetFavoritesOptions = { userId?: string } & Pagination;
+
+export class E621ApiClient {
+  protected static readonly BASE_URL = "https://e621.net/";
+
+  private readonly client: string;
+  private readonly isBrowser: boolean;
+  private credentials: Credentials | null = null;
+
+  constructor(options: E621ApiOptions) {
+    this.client = options.client;
+    this.isBrowser = options.isBrowser;
+    this.credentials = options.credentials || null;
+  }
+
+  // Users
+  public async getUsers(options: GetUsersOptions = {}): Promise<E621User[]> {
+    const users = await this.get<UserResponse[]>({
+      route: "users",
+      params: translateOptions(options, {
+        nameMatches: "search[name_matches]",
+      }),
+    });
+    return users?.map(parseUser) || [];
+  }
+
+  public async getUserById(id: EntityId): Promise<E621User | null> {
+    const user = await this.get<UserResponse>({ route: ["users", id] });
+    return user ? parseUser(user) : null;
+  }
+
+  // Posts
+  public async getPosts(options: GetPostsOptions = {}): Promise<E621Post[]> {
+    const response = await this.get<GetPostsResponse>({
+      route: "posts",
+      params: options,
+    });
+    return response?.posts.map(parsePost) || [];
+  }
+
+  public async getPostById(id: EntityId): Promise<E621Post | null> {
+    const response = await this.get<GetPostResponse>({ route: ["posts", id] });
+    return response?.post ? parsePost(response.post) : null;
+  }
+
+  // Favorites
+  public async getFavorites(
+    options: GetFavoritesOptions = {}
+  ): Promise<E621Post[]> {
+    const response = await this.get<GetFavoritesResponse>({
+      route: "favorites",
+      params: translateOptions(options, { userId: "user_id" }),
+    });
+    return response?.posts?.map(parsePost) || [];
+  }
+
+  // Account
+  public setCredentials(credentials: Credentials | null): E621ApiClient {
+    this.credentials = credentials;
+    return this;
+  }
+
+  public async checkCredentials(credentials?: Credentials): Promise<boolean> {
+    if (credentials) {
+      this.setCredentials(credentials);
+    }
+
+    const headers = new E621ApiHeaders();
+    if (!this.isBrowser) {
+      headers.addUserAgent(this.client);
+    }
+
+    return await fetch(this.buildUrl("favorites"), {
+      headers: headers.addAuthorization(this.credentials).build(),
+    })
+      .then((res) => res.ok)
+      .catch(() => false);
+  }
+
+  public async get<E>({
+    route,
+    params,
+    headers = new E621ApiHeaders(),
+  }: GetOptions): Promise<E | null> {
+    if (!this.isBrowser) {
+      headers.addUserAgent(this.client);
+    }
+
+    const response = await fetch(this.buildUrl(route, params), {
+      method: "GET",
+      headers: headers.addAuthorization(this.credentials).build(),
+    });
+    return response.json().catch(() => null);
+  }
+
+  private buildUrl(route: Route, params: Params = {}): string {
+    const queryParams = new URLSearchParams(params);
+    const url = E621ApiClient.BASE_URL + ensureArray(route).join("/") + ".json";
+
+    if (this.isBrowser) {
+      queryParams.set("_client", this.client);
+    }
+
+    return queryParams.size > 0 ? `${url}?${queryParams}` : url;
+  }
+}

package/src/client/E621ApiHeaders.ts

@@ -0,0 +1,51 @@
+import { Credentials } from "./E621ApiClient";
+
+export class E621ApiHeaders {
+  private readonly value: Record<string, string>;
+
+  constructor(value: Record<string, string> = {}) {
+    this.value = value;
+  }
+
+  public addAuthorization(credentials: Credentials | null): E621ApiHeaders {
+    if (credentials) {
+      this.value.Authorization = E621ApiHeaders.buildAuthorization(credentials);
+    }
+    return this;
+  }
+
+  public addFormContentType(): E621ApiHeaders {
+    this.value["Content-Type"] =
+      "application/x-www-form-urlencoded; charset=UTF-8";
+    return this;
+  }
+
+  public addUserAgent(userAgent: string): E621ApiHeaders {
+    this.value["User-Agent"] = userAgent;
+    return this;
+  }
+
+  public build(): Record<string, string> {
+    return this.value;
+  }
+
+  protected static buildAuthorization({ username, apiKey }: Credentials) {
+    const creds = `${username}:${apiKey}`;
+
+    if (canUseWindow()) {
+      return `Basic ${window.btoa(creds)}`;
+    } else if (canUseBuffer()) {
+      return `Basic ${Buffer.from(creds).toString("base64")}`;
+    } else {
+      throw new Error("Environment does not support base64 encoding");
+    }
+  }
+}
+
+function canUseWindow() {
+  return typeof window !== "undefined";
+}
+
+function canUseBuffer() {
+  return typeof Buffer !== "undefined" && typeof Buffer.from === "function";
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./client/E621ApiClient";
+export * from "./types/e621/E621User";
+export * from "./types/e621/E621Post";

package/src/types/e621/E621Post.ts

@@ -0,0 +1,173 @@
+export interface PostResponse {
+  id: number;
+  created_at: string;
+  updated_at: string;
+  file: {
+    width: number;
+    height: number;
+    ext: string;
+    size: number;
+    md5: string;
+    url: string;
+  };
+  preview: {
+    width: number;
+    height: number;
+    url: string | null;
+  };
+  sample: {
+    has: boolean;
+    width: number;
+    height: number;
+    url: string | null;
+  };
+  score: {
+    up: number;
+    down: number;
+    total: number;
+  };
+  tags: {
+    general: string[];
+    artist: string[];
+    copyright: string[];
+    character: string[];
+    species: string[];
+    invalid: string[];
+    meta: string[];
+    lore: string[];
+  };
+  locked_tags: string[];
+  change_seq: number;
+  flags: {
+    pending: boolean;
+    flagged: boolean;
+    note_locked: boolean;
+    status_locked: boolean;
+    rating_locked: boolean;
+    deleted: boolean;
+  };
+  rating: string;
+  fav_count: number;
+  sources: string[];
+  pools: number[];
+  relationships: {
+    parent_id: number | null;
+    has_children: boolean;
+    has_active_children: boolean;
+    children: number[];
+  };
+  approver_id: number | null;
+  uploader_id: number;
+  description: string;
+  comment_count: number;
+  is_favorited: boolean;
+  has_notes: boolean;
+  duration: number | null;
+}
+
+export interface E621Post {
+  id: number;
+  createdAt: Date;
+  updatedAt: Date;
+  file: {
+    width: number;
+    height: number;
+    ext: string;
+    size: number;
+    md5: string;
+    url: string;
+  };
+  preview: {
+    width: number;
+    height: number;
+    url: string | null;
+  };
+  sample: {
+    has: boolean;
+    width: number;
+    height: number;
+    url: string | null;
+  };
+  score: {
+    up: number;
+    down: number;
+    total: number;
+  };
+  tags: {
+    general: string[];
+    artist: string[];
+    copyright: string[];
+    character: string[];
+    species: string[];
+    invalid: string[];
+    meta: string[];
+    lore: string[];
+  };
+  lockedTags: string[];
+  changeSeq: number;
+  flags: {
+    pending: boolean;
+    flagged: boolean;
+    noteLocked: boolean;
+    statusLocked: boolean;
+    ratingLocked: boolean;
+    deleted: boolean;
+  };
+  rating: string;
+  favCount: number;
+  sources: string[];
+  pools: number[];
+  relationships: {
+    parentId: number | null;
+    hasChildren: boolean;
+    hasActiveChildren: boolean;
+    children: number[];
+  };
+  approverId: number | null;
+  uploaderId: number;
+  description: string;
+  commentCount: number;
+  isFavorited: boolean;
+  hasNotes: boolean;
+  duration: number | null;
+}
+
+export function parsePost(post: PostResponse): E621Post {
+  return {
+    id: post.id,
+    createdAt: new Date(post.created_at),
+    updatedAt: new Date(post.updated_at),
+    file: post.file,
+    preview: post.preview,
+    sample: post.sample,
+    score: post.score,
+    tags: post.tags,
+    lockedTags: post.locked_tags,
+    changeSeq: post.change_seq,
+    flags: {
+      pending: post.flags.pending,
+      flagged: post.flags.flagged,
+      noteLocked: post.flags.note_locked,
+      statusLocked: post.flags.status_locked,
+      ratingLocked: post.flags.rating_locked,
+      deleted: post.flags.deleted,
+    },
+    rating: post.rating,
+    favCount: post.fav_count,
+    sources: post.sources,
+    pools: post.pools,
+    relationships: {
+      parentId: post.relationships.parent_id,
+      hasChildren: post.relationships.has_children,
+      hasActiveChildren: post.relationships.has_active_children,
+      children: post.relationships.children,
+    },
+    approverId: post.approver_id,
+    uploaderId: post.uploader_id,
+    description: post.description,
+    commentCount: post.comment_count,
+    isFavorited: post.is_favorited,
+    hasNotes: post.has_notes,
+    duration: post.duration,
+  };
+}

package/src/types/e621/E621User.ts

@@ -0,0 +1,108 @@
+export interface UserResponse {
+  wiki_page_version_count: number;
+  artist_version_count: number;
+  pool_version_count: number;
+  forum_post_count: number;
+  comment_count: number;
+  flag_count: number;
+  favorite_count: number;
+  positive_feedback_count: number;
+  neutral_feedback_count: number;
+  negative_feedback_count: number;
+  upload_limit: number;
+  profile_about: string;
+  profile_artinfo: string;
+  id: number;
+  created_at: string;
+  name: string;
+  level: number;
+  base_upload_limit: number;
+  post_upload_count: number;
+  post_update_count: number;
+  note_update_count: number;
+  is_banned: boolean;
+  can_approve_posts: boolean;
+  can_upload_free: boolean;
+  level_string: string;
+  avatar_id: number | null;
+}
+
+export interface E621User {
+  id: number;
+
+  profile: {
+    name: string;
+    level: number;
+    about: string;
+    artInfo: string;
+    avatarId: number | null;
+    createdAt: Date;
+    levelString: string;
+  };
+
+  counts: {
+    wikiPageVersion: number;
+    artistVersion: number;
+    poolVersion: number;
+    forumPost: number;
+    comment: number;
+    flag: number;
+    favorite: number;
+    positiveFeedback: number;
+    neutralFeedback: number;
+    negativeFeedback: number;
+  };
+
+  limits: {
+    upload: number;
+    baseUpload: number;
+    postUpload: number;
+    postUpdate: number;
+    noteUpdate: number;
+  };
+
+  isBanned: boolean;
+  canApprovePosts: boolean;
+  canUploadFree: boolean;
+}
+
+export function parseUser(user: UserResponse): E621User {
+  return {
+    id: user.id,
+
+    profile: {
+      name: user.name,
+      level: user.level,
+      about: user.profile_about,
+      artInfo: user.profile_artinfo,
+      avatarId: user.avatar_id,
+      createdAt: new Date(user.created_at),
+      levelString: user.level_string,
+    },
+
+    counts: {
+      wikiPageVersion: user.wiki_page_version_count,
+      artistVersion: user.artist_version_count,
+      poolVersion: user.pool_version_count,
+      forumPost: user.forum_post_count,
+      comment: user.comment_count,
+      flag: user.flag_count,
+      favorite: user.favorite_count,
+      positiveFeedback: user.positive_feedback_count,
+      neutralFeedback: user.neutral_feedback_count,
+      negativeFeedback: user.negative_feedback_count,
+    },
+
+    limits: {
+      upload: user.upload_limit,
+      baseUpload: user.base_upload_limit,
+      postUpload: user.post_upload_count,
+      postUpdate: user.post_update_count,
+      noteUpdate: user.note_update_count,
+    },
+
+    isBanned: user.is_banned,
+    canApprovePosts: user.can_approve_posts,
+    canUploadFree: user.can_upload_free,
+  };
+}

package/src/types/responses.ts

@@ -0,0 +1,13 @@
+import { PostResponse } from "./e621/E621Post";
+
+export type GetFavoritesResponse = {
+  posts: PostResponse[] | null;
+};
+
+export type GetPostResponse = {
+  post: PostResponse | null;
+};
+
+export type GetPostsResponse = {
+  posts: PostResponse[];
+};

package/src/utils.ts

@@ -0,0 +1,19 @@
+export function ensureArray<T>(value: T | T[]): T[] {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+
+export function translateOptions<Options extends Record<string, string>>(
+  options: Options,
+  table: Partial<Options>
+): Record<string, string> {
+  const params: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(options)) {
+    params[table[key] ?? key] = value;
+  }
+
+  return params;
+}

package/tsconfig.json

@@ -0,0 +1,109 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  }
+}