@natsuneko-laboratory/catalyst-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,821 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  AuthInterceptor: () => AuthInterceptor,
+  CatalystClient: () => CatalystClient,
+  CatalystEndpoint: () => CatalystEndpoint,
+  CatalystError: () => CatalystError,
+  CatalystTS: () => CatalystTS,
+  EgeriaClient: () => EgeriaClient,
+  EgeriaEndpoint: () => EgeriaEndpoint,
+  HttpClient: () => HttpClient,
+  ISSUER_CATALYST_SYSTEM_MESSAGE: () => ISSUER_CATALYST_SYSTEM_MESSAGE,
+  ISSUER_CATALYST_USER_MESSAGE: () => ISSUER_CATALYST_USER_MESSAGE,
+  ISSUER_EGERIA_SYSTEM_MESSAGE: () => ISSUER_EGERIA_SYSTEM_MESSAGE,
+  LoggingInterceptor: () => LoggingInterceptor,
+  MediaClient: () => MediaClient,
+  MediaEndpoint: () => MediaEndpoint,
+  OAuth: () => OAuth,
+  OAuthError: () => OAuthError,
+  PKCE: () => PKCE,
+  PUBLIC_API_ENDPOINT: () => PUBLIC_API_ENDPOINT,
+  PUBLIC_AUTHORIZE_ENDPOINT: () => PUBLIC_AUTHORIZE_ENDPOINT,
+  PUBLIC_GRAPHQL_ENDPOINT: () => PUBLIC_GRAPHQL_ENDPOINT,
+  SteambirdClient: () => SteambirdClient,
+  SteambirdEndpoint: () => SteambirdEndpoint,
+  UserAgentInterceptor: () => UserAgentInterceptor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/apiError.ts
+var ApiError = class _ApiError extends Error {
+  constructor(message, statusCode, cause) {
+    super(message);
+    this.statusCode = statusCode;
+    this.cause = cause;
+    this.name = "ApiError";
+  }
+  static invalid() {
+    return new _ApiError("Invalid response");
+  }
+  static httpError(statusCode) {
+    return new _ApiError(`HTTP Error: ${statusCode}`, statusCode);
+  }
+  static decodingError(cause) {
+    return new _ApiError("Decoding error", void 0, cause);
+  }
+  static unauthorized() {
+    return new _ApiError("Unauthorized", 401);
+  }
+};
+var CatalystError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CatalystError";
+  }
+};
+
+// src/types/constants.ts
+var PUBLIC_API_ENDPOINT = "https://api.natsuneko.com";
+var PUBLIC_GRAPHQL_ENDPOINT = "https://graphql.natsuneko.com";
+var PUBLIC_AUTHORIZE_ENDPOINT = "https://accounts.natsuneko.com/authorize";
+
+// src/clients/httpClient.ts
+var HttpClient = class {
+  constructor(interceptors = []) {
+    this.interceptors = interceptors;
+  }
+  buildRequest(endpoint) {
+    const url = new URL(endpoint.path, PUBLIC_API_ENDPOINT);
+    if (endpoint.queryParameters != null) {
+      for (const [key, value] of Object.entries(endpoint.queryParameters)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    const headers = new Headers(endpoint.headers);
+    let body;
+    if (endpoint.body != null) {
+      body = JSON.stringify(endpoint.body);
+      headers.set("Content-Type", "application/json");
+    }
+    return new Request(url.toString(), {
+      method: endpoint.method,
+      headers,
+      body
+    });
+  }
+  async request(endpoint) {
+    let req = this.buildRequest(endpoint);
+    for (const interceptor of this.interceptors) {
+      req = await interceptor.adapt(req);
+    }
+    const response = await this.executeWithRetry(req, endpoint);
+    const text = await response.text();
+    if (!text) throw new Error("Empty response body");
+    try {
+      return JSON.parse(text);
+    } catch (cause) {
+      throw ApiError.decodingError(cause);
+    }
+  }
+  async requestVoid(endpoint) {
+    let req = this.buildRequest(endpoint);
+    for (const interceptor of this.interceptors) {
+      req = await interceptor.adapt(req);
+    }
+    await this.executeWithRetry(req, endpoint);
+  }
+  async requestRaw(endpoint) {
+    let req = this.buildRequest(endpoint);
+    for (const interceptor of this.interceptors) {
+      req = await interceptor.adapt(req);
+    }
+    const response = await this.executeWithRetry(req, endpoint);
+    return response.arrayBuffer();
+  }
+  async executeWithRetry(req, endpoint) {
+    const response = await fetch(req);
+    if (!response.ok) {
+      const error = ApiError.httpError(response.status);
+      for (const interceptor of this.interceptors) {
+        const shouldRetry = await interceptor.retry(req, error);
+        if (shouldRetry) {
+          return this.executeWithRetry(req, endpoint);
+        }
+      }
+      throw error;
+    }
+    return response;
+  }
+};
+
+// src/endpoints/catalystEndpoint.ts
+function buildTimelineParams(opts) {
+  const params = {};
+  if (opts.since != null) params["since"] = opts.since;
+  if (opts.until != null) params["until"] = opts.until;
+  return Object.keys(params).length > 0 ? params : void 0;
+}
+var CatalystEndpoint = {
+  createAlbum(data) {
+    return { path: "/catalyst/v1/album", method: "POST", body: data };
+  },
+  getAlbum(id, opts = {}) {
+    return {
+      path: `/catalyst/v1/album/by/id/${id}`,
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  editAlbum(id, data) {
+    return { path: `/catalyst/v1/album/by/id/${id}`, method: "PATCH", body: data };
+  },
+  insertToAlbum(id, data) {
+    return { path: `/catalyst/v1/album/by/id/${id}`, method: "PUT", body: data };
+  },
+  removeFromAlbum(id, data) {
+    return { path: `/catalyst/v1/album/by/id/${id}`, method: "PUT", body: data };
+  },
+  deleteAlbum(id) {
+    return { path: `/catalyst/v1/album/by/id/${id}`, method: "DELETE" };
+  },
+  listAlbums(username, includeSmartAlbums = false) {
+    return {
+      path: `/catalyst/v1/album/by/user/${username}`,
+      method: "GET",
+      queryParameters: { include_smart_albums: String(includeSmartAlbums) }
+    };
+  },
+  searchAlbum(q, includeSmartAlbums = false) {
+    return {
+      path: "/catalyst/v1/album/search",
+      method: "GET",
+      queryParameters: { q, include_smart_album: String(includeSmartAlbums) }
+    };
+  },
+  customReactions() {
+    return { path: "/catalyst/v1/reactions", method: "GET" };
+  },
+  relationships(id) {
+    return { path: `/catalyst/v1/relationships/${id}`, method: "GET" };
+  },
+  follow(data) {
+    return { path: "/catalyst/v1/relationships", method: "POST", body: data };
+  },
+  remove(data) {
+    return { path: "/catalyst/v1/relationships", method: "DELETE", body: data };
+  },
+  createSmartAlbum(data) {
+    return { path: "/catalyst/v1/smart-album", method: "POST", body: data };
+  },
+  getSmartAlbum(id, opts = {}) {
+    return {
+      path: `/catalyst/v1/smart-album/by/id/${id}`,
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  editSmartAlbum(id, data) {
+    return { path: `/catalyst/v1/smart-album/by/id/${id}`, method: "PATCH", body: data };
+  },
+  deleteSmartAlbum(id) {
+    return { path: `/catalyst/v1/smart-album/by/id/${id}`, method: "DELETE" };
+  },
+  searchSmartAlbum(q) {
+    return { path: "/catalyst/v1/smart-album/search", method: "GET", queryParameters: { q } };
+  },
+  createStatus(data) {
+    return { path: "/catalyst/v1/status", method: "POST", body: data };
+  },
+  getStatus(id) {
+    return { path: `/catalyst/v1.1/status/${id}`, method: "GET" };
+  },
+  editStatus(id, data) {
+    return { path: `/catalyst/v1/status/${id}`, method: "PATCH", body: data };
+  },
+  deleteStatus(id) {
+    return { path: `/catalyst/v1/status/${id}`, method: "DELETE" };
+  },
+  isFavorited(id) {
+    return { path: `/catalyst/v1/status/${id}/favorite`, method: "GET" };
+  },
+  favorite(id) {
+    return { path: `/catalyst/v1/status/${id}/favorite`, method: "POST" };
+  },
+  unfavorite(id) {
+    return { path: `/catalyst/v1/status/${id}/favorite`, method: "DELETE" };
+  },
+  reactions(id) {
+    return { path: `/catalyst/v1/status/${id}/reactions`, method: "GET" };
+  },
+  react(id, symbol) {
+    return { path: `/catalyst/v1/status/${id}/reactions/${symbol}`, method: "POST" };
+  },
+  unreact(id, symbol) {
+    return { path: `/catalyst/v1/status/${id}/reactions/${symbol}`, method: "DELETE" };
+  },
+  contestTimeline(slug, opts = {}) {
+    return {
+      path: `/catalyst/v1/timeline/contest/by/slug/${slug}`,
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  favoriteTimeline(opts = {}) {
+    return {
+      path: "/catalyst/v1/timeline/favorite",
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  firehoseTimeline(opts = {}) {
+    return {
+      path: "/catalyst/v1.1/timeline/firehose",
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  galleryTimeline(opts = {}) {
+    return {
+      path: "/catalyst/v1/timeline/gallery",
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  homeTimeline(opts = {}) {
+    return {
+      path: "/catalyst/v1.1/timeline/home",
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  searchTimeline(opts = {}) {
+    const params = {};
+    if (opts.q != null) params["q"] = opts.q;
+    if (opts.exact != null) params["exact"] = String(opts.exact);
+    if (opts.since != null) params["since"] = opts.since;
+    if (opts.until != null) params["until"] = opts.until;
+    return {
+      path: "/catalyst/v1/timeline/search",
+      method: "GET",
+      queryParameters: Object.keys(params).length > 0 ? params : void 0
+    };
+  },
+  userTimeline(username, opts = {}) {
+    const params = {};
+    if (opts.trimUser != null) params["trim_user"] = String(opts.trimUser);
+    if (opts.excludeSensitive != null) params["exclude_sensitive"] = String(opts.excludeSensitive);
+    if (opts.since != null) params["since"] = opts.since;
+    if (opts.until != null) params["until"] = opts.until;
+    return {
+      path: `/catalyst/v1/timeline/user/by/username/${username}`,
+      method: "GET",
+      queryParameters: Object.keys(params).length > 0 ? params : void 0
+    };
+  },
+  userGalleryTimeline(username, opts = {}) {
+    return {
+      path: `/catalyst/v1/timeline/user/by/username/${username}/gallery`,
+      method: "GET",
+      queryParameters: buildTimelineParams(opts)
+    };
+  },
+  trend() {
+    return { path: "/catalyst/v1/trend", method: "GET" };
+  }
+};
+
+// src/clients/catalystClient.ts
+var CatalystClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // Albums
+  createAlbum(data) {
+    return this.http.request(CatalystEndpoint.createAlbum(data));
+  }
+  getAlbum(id, opts = {}) {
+    return this.http.request(CatalystEndpoint.getAlbum(id, opts));
+  }
+  editAlbum(id, data) {
+    return this.http.requestVoid(CatalystEndpoint.editAlbum(id, data));
+  }
+  insertToAlbum(id, data) {
+    return this.http.requestVoid(CatalystEndpoint.insertToAlbum(id, data));
+  }
+  removeFromAlbum(id, data) {
+    return this.http.requestVoid(CatalystEndpoint.removeFromAlbum(id, data));
+  }
+  deleteAlbum(id) {
+    return this.http.requestVoid(CatalystEndpoint.deleteAlbum(id));
+  }
+  listAlbums(username, includeSmartAlbums = true) {
+    return this.http.request(CatalystEndpoint.listAlbums(username, includeSmartAlbums));
+  }
+  searchAlbums(q, includeSmartAlbums = true) {
+    return this.http.request(CatalystEndpoint.searchAlbum(q, includeSmartAlbums));
+  }
+  // Reactions
+  customReactions() {
+    return this.http.request(CatalystEndpoint.customReactions());
+  }
+  // Relationships
+  relationships(id) {
+    return this.http.request(CatalystEndpoint.relationships(id));
+  }
+  follow(data) {
+    return this.http.requestVoid(CatalystEndpoint.follow(data));
+  }
+  remove(data) {
+    return this.http.requestVoid(CatalystEndpoint.remove(data));
+  }
+  // Smart Albums
+  createSmartAlbum(data) {
+    return this.http.request(CatalystEndpoint.createSmartAlbum(data));
+  }
+  getSmartAlbum(id, opts = {}) {
+    return this.http.request(CatalystEndpoint.getSmartAlbum(id, opts));
+  }
+  editSmartAlbum(id, data) {
+    return this.http.requestVoid(CatalystEndpoint.editSmartAlbum(id, data));
+  }
+  deleteSmartAlbum(id) {
+    return this.http.requestVoid(CatalystEndpoint.deleteSmartAlbum(id));
+  }
+  searchSmartAlbum(q) {
+    return this.http.request(CatalystEndpoint.searchSmartAlbum(q));
+  }
+  // Statuses
+  createStatus(data) {
+    return this.http.request(CatalystEndpoint.createStatus(data));
+  }
+  getStatus(id) {
+    return this.http.request(CatalystEndpoint.getStatus(id));
+  }
+  editStatus(id, data) {
+    return this.http.requestVoid(CatalystEndpoint.editStatus(id, data));
+  }
+  deleteStatus(id) {
+    return this.http.requestVoid(CatalystEndpoint.deleteStatus(id));
+  }
+  isFavorited(id) {
+    return this.http.request(CatalystEndpoint.isFavorited(id));
+  }
+  favorite(id) {
+    return this.http.requestVoid(CatalystEndpoint.favorite(id));
+  }
+  unfavorite(id) {
+    return this.http.requestVoid(CatalystEndpoint.unfavorite(id));
+  }
+  reactions(id) {
+    return this.http.request(CatalystEndpoint.reactions(id));
+  }
+  react(id, symbol) {
+    return this.http.requestVoid(CatalystEndpoint.react(id, symbol));
+  }
+  unreact(id, symbol) {
+    return this.http.requestVoid(CatalystEndpoint.unreact(id, symbol));
+  }
+  // Timelines
+  contestTimeline(slug, opts = {}) {
+    return this.http.request(CatalystEndpoint.contestTimeline(slug, opts));
+  }
+  favoriteTimeline(opts = {}) {
+    return this.http.request(CatalystEndpoint.favoriteTimeline(opts));
+  }
+  firehoseTimeline(opts = {}) {
+    return this.http.request(CatalystEndpoint.firehoseTimeline(opts));
+  }
+  galleryTimeline(opts = {}) {
+    return this.http.request(CatalystEndpoint.galleryTimeline(opts));
+  }
+  homeTimeline(opts = {}) {
+    return this.http.request(CatalystEndpoint.homeTimeline(opts));
+  }
+  searchTimeline(opts = {}) {
+    return this.http.request(CatalystEndpoint.searchTimeline(opts));
+  }
+  userTimeline(username, opts = {}) {
+    return this.http.request(CatalystEndpoint.userTimeline(username, opts));
+  }
+  userGalleryTimeline(username, opts = {}) {
+    return this.http.request(CatalystEndpoint.userGalleryTimeline(username, opts));
+  }
+  trend() {
+    return this.http.request(CatalystEndpoint.trend());
+  }
+};
+
+// src/endpoints/egeriaEndpoint.ts
+var EgeriaEndpoint = {
+  me() {
+    return { path: "/egeria/v1/me", method: "GET" };
+  },
+  update(data) {
+    return { path: "/egeria/v1/me", method: "PATCH", body: data };
+  },
+  search(q) {
+    return { path: "/egeria/v1/search", method: "GET", queryParameters: { q } };
+  },
+  userById(id) {
+    return { path: `/egeria/v1/user/by/id/${id}`, method: "GET" };
+  },
+  userByUsername(username) {
+    return { path: `/egeria/v1/user/by/username/${username}`, method: "GET" };
+  }
+};
+
+// src/clients/egeriaClient.ts
+var EgeriaClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  me() {
+    return this.http.request(EgeriaEndpoint.me());
+  }
+  update(data) {
+    return this.http.requestVoid(EgeriaEndpoint.update(data));
+  }
+  search(q) {
+    return this.http.request(EgeriaEndpoint.search(q));
+  }
+  userById(id) {
+    return this.http.request(EgeriaEndpoint.userById(id));
+  }
+  userByUsername(username) {
+    return this.http.request(EgeriaEndpoint.userByUsername(username));
+  }
+};
+
+// src/endpoints/mediaEndpoint.ts
+var MediaEndpoint = {
+  download(data) {
+    return { path: "/media/v1/download", method: "POST", body: data };
+  },
+  delete(data) {
+    return { path: "/media/v1/upload", method: "DELETE", body: data };
+  },
+  upload() {
+    return { path: "/media/v2/upload", method: "POST" };
+  }
+};
+
+// src/clients/mediaClient.ts
+var MediaClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  download(data) {
+    return this.http.requestRaw(MediaEndpoint.download(data));
+  }
+  delete(data) {
+    return this.http.requestVoid(MediaEndpoint.delete(data));
+  }
+  upload() {
+    return this.http.request(MediaEndpoint.upload());
+  }
+};
+
+// src/endpoints/steambirdEndpoint.ts
+var SteambirdEndpoint = {
+  notifications(issuer, opts = {}) {
+    const params = { issuer };
+    if (opts.since != null) params["since"] = opts.since;
+    if (opts.until != null) params["until"] = opts.until;
+    return { path: "/steambird/v1/notifications", method: "GET", queryParameters: params };
+  },
+  read(id) {
+    return { path: `/steambird/v1/notifications/${id}`, method: "POST" };
+  },
+  readAll(issuer) {
+    return {
+      path: "/steambird/v1/notifications/all",
+      method: "POST",
+      queryParameters: issuer != null ? { issuer } : void 0
+    };
+  },
+  unreads(issuers = []) {
+    return {
+      path: "/steambird/v1/notifications/unread",
+      method: "GET",
+      queryParameters: issuers.length > 0 ? { issuers: issuers.join(",") } : void 0
+    };
+  }
+};
+
+// src/clients/steambirdClient.ts
+var ISSUER_CATALYST_SYSTEM_MESSAGE = "natsuneko-laboratory:catalyst";
+var ISSUER_CATALYST_USER_MESSAGE = "natsuneko-laboratory:catalyst-message";
+var ISSUER_EGERIA_SYSTEM_MESSAGE = "natsuneko-laboratory:egeria";
+var SteambirdClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  ISSUER_CATALYST_SYSTEM_MESSAGE = ISSUER_CATALYST_SYSTEM_MESSAGE;
+  ISSUER_CATALYST_USER_MESSAGE = ISSUER_CATALYST_USER_MESSAGE;
+  ISSUER_EGERIA_SYSTEM_MESSAGE = ISSUER_EGERIA_SYSTEM_MESSAGE;
+  notifications(issuer, opts = {}) {
+    return this.http.request(SteambirdEndpoint.notifications(issuer, opts));
+  }
+  read(id) {
+    return this.http.requestVoid(SteambirdEndpoint.read(id));
+  }
+  readAll(issuer) {
+    return this.http.requestVoid(SteambirdEndpoint.readAll(issuer));
+  }
+  unreads(issuers = []) {
+    return this.http.request(SteambirdEndpoint.unreads(issuers));
+  }
+};
+
+// src/interceptors/authInterceptor.ts
+var AuthInterceptor = class {
+  constructor(tokenProvider) {
+    this.tokenProvider = tokenProvider;
+  }
+  retryCounts = /* @__PURE__ */ new Map();
+  maxRetryCount = 5;
+  async adapt(request) {
+    const token = await this.tokenProvider();
+    if (token == null) return request;
+    const headers = new Headers(request.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    return new Request(request, { headers });
+  }
+  async retry(request, error) {
+    if (!(error instanceof ApiError) || error.statusCode !== 401) return false;
+    const key = this.makeRequestKey(request);
+    const count = this.retryCounts.get(key) ?? 0;
+    if (count >= this.maxRetryCount) {
+      this.retryCounts.delete(key);
+      return false;
+    }
+    this.retryCounts.set(key, count + 1);
+    return true;
+  }
+  makeRequestKey(request) {
+    return `${request.method}:${request.url}`;
+  }
+};
+
+// src/interceptors/userAgentInterceptor.ts
+var UserAgentInterceptor = class {
+  agent;
+  constructor() {
+    this.agent = "CatalystTS/0.1.0";
+  }
+  async adapt(request) {
+    const headers = new Headers(request.headers);
+    headers.set("User-Agent", this.agent);
+    return new Request(request, { headers });
+  }
+  async retry(_request, _error) {
+    return false;
+  }
+};
+
+// src/oauth/oauth.ts
+var OAuthError = class extends Error {
+  constructor(message, kind, info) {
+    super(message);
+    this.kind = kind;
+    this.info = info;
+    this.name = "OAuthError";
+  }
+};
+var OAuth = class {
+  constructor(clientId, clientSecret) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+  }
+  async getAccessTokenByCode(code, redirectUri, pkce) {
+    const body = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: this.clientId,
+      code_verifier: pkce.verifier
+    });
+    return this.postToken(body);
+  }
+  async getAccessTokenByRefreshToken(refreshToken) {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.clientId,
+      client_secret: this.clientSecret
+    });
+    return this.postToken(body);
+  }
+  getAuthorizeURL(redirectUri, pkce, state) {
+    const url = new URL(PUBLIC_AUTHORIZE_ENDPOINT);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("client_id", this.clientId);
+    url.searchParams.set("redirect_uri", redirectUri);
+    url.searchParams.set("state", state);
+    url.searchParams.set("code_challenge", pkce.challenge);
+    url.searchParams.set("code_challenge_method", pkce.method);
+    return url;
+  }
+  getAuthorizationCode(callbackUrl, expectedState, expectedRedirectUri) {
+    this.verifyAuthorizationResponse(callbackUrl, expectedState, expectedRedirectUri);
+    const error = callbackUrl.searchParams.get("error");
+    if (error != null) {
+      throw new OAuthError("Authorization request failed", "authorizationRequestFailed", {
+        error,
+        description: callbackUrl.searchParams.get("error_description") ?? void 0,
+        uri: callbackUrl.searchParams.get("error_uri") ?? void 0
+      });
+    }
+    const code = callbackUrl.searchParams.get("code");
+    if (code == null) throw new OAuthError("Invalid authorization response", "invalidAuthorizationResponse");
+    return code;
+  }
+  verifyAuthorizationResponse(url, expectedState, expectedRedirectUri) {
+    if (!url.href.startsWith(expectedRedirectUri + "?")) {
+      throw new OAuthError("Invalid authorization response", "invalidAuthorizationResponse");
+    }
+    if (url.searchParams.get("state") !== expectedState) {
+      throw new OAuthError("Invalid authorization response", "invalidAuthorizationResponse");
+    }
+  }
+  async postToken(body) {
+    const response = await fetch(`${PUBLIC_API_ENDPOINT}/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      throw new OAuthError("Invalid token response", "invalidTokenResponse");
+    }
+    const json = await response.json();
+    return {
+      accessToken: json["access_token"],
+      refreshToken: json["refresh_token"],
+      tokenType: json["token_type"]
+    };
+  }
+};
+
+// src/CatalystTS.ts
+var CatalystTS = class {
+  clientId;
+  clientSecret;
+  _accessToken;
+  _refreshToken;
+  http;
+  constructor(opts) {
+    this.clientId = opts.clientId;
+    this.clientSecret = opts.clientSecret;
+    this._accessToken = opts.accessToken;
+    this._refreshToken = opts.refreshToken;
+    const interceptors = [
+      ...opts.interceptors ?? [],
+      new AuthInterceptor(() => Promise.resolve(this._accessToken)),
+      new UserAgentInterceptor()
+    ];
+    this.http = new HttpClient(interceptors);
+  }
+  get accessToken() {
+    return this._accessToken;
+  }
+  get refreshToken() {
+    return this._refreshToken;
+  }
+  setCredential(accessToken, refreshToken) {
+    this._accessToken = accessToken;
+    this._refreshToken = refreshToken;
+  }
+  async refresh() {
+    if (this._refreshToken == null) throw new Error("refreshToken is not set");
+    const token = await this.oauth.getAccessTokenByRefreshToken(this._refreshToken);
+    this._accessToken = token.accessToken;
+    this._refreshToken = token.refreshToken;
+    return token;
+  }
+  get oauth() {
+    return new OAuth(this.clientId, this.clientSecret);
+  }
+  get catalyst() {
+    return new CatalystClient(this.http);
+  }
+  get egeria() {
+    return new EgeriaClient(this.http);
+  }
+  get media() {
+    return new MediaClient(this.http);
+  }
+  get steambird() {
+    return new SteambirdClient(this.http);
+  }
+};
+
+// src/interceptors/loggingInterceptor.ts
+var LoggingInterceptor = class {
+  async adapt(request) {
+    console.log(`[CatalystTS] ${request.method} ${request.url}`);
+    return request;
+  }
+  async retry(request, error) {
+    console.log(`[CatalystTS] Retry ${request.method} ${request.url}`, error);
+    return false;
+  }
+};
+
+// src/oauth/pkce.ts
+var import_js_sha256 = require("js-sha256");
+var PKCE = class _PKCE {
+  constructor(verifier, challenge) {
+    this.verifier = verifier;
+    this.challenge = challenge;
+  }
+  method = "S256";
+  static async create() {
+    const verifier = _PKCE.generateVerifier();
+    const challenge = await _PKCE.computeChallenge(verifier);
+    return new _PKCE(verifier, challenge);
+  }
+  static generateVerifier() {
+    const bytes = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(bytes);
+    return _PKCE.base64url(bytes);
+  }
+  static async computeChallenge(verifier) {
+    const encoded = new TextEncoder().encode(verifier);
+    const hash = import_js_sha256.sha256.create();
+    hash.update(encoded);
+    const digest = hash.array();
+    return _PKCE.base64url(new Uint8Array(digest));
+  }
+  static base64url(bytes) {
+    return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthInterceptor,
+  CatalystClient,
+  CatalystEndpoint,
+  CatalystError,
+  CatalystTS,
+  EgeriaClient,
+  EgeriaEndpoint,
+  HttpClient,
+  ISSUER_CATALYST_SYSTEM_MESSAGE,
+  ISSUER_CATALYST_USER_MESSAGE,
+  ISSUER_EGERIA_SYSTEM_MESSAGE,
+  LoggingInterceptor,
+  MediaClient,
+  MediaEndpoint,
+  OAuth,
+  OAuthError,
+  PKCE,
+  PUBLIC_API_ENDPOINT,
+  PUBLIC_AUTHORIZE_ENDPOINT,
+  PUBLIC_GRAPHQL_ENDPOINT,
+  SteambirdClient,
+  SteambirdEndpoint,
+  UserAgentInterceptor
+});