comic-vine-sdk 1.3.2 → 2.0.0

package/lib/index.js

@@ -0,0 +1,845 @@
+import { HttpClient, HttpClientError } from '@http-client-toolkit/core';
+import { z, ZodError } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+
+// src/http-client/status-code.ts
+var StatusCode = /* @__PURE__ */ ((StatusCode2) => {
+  StatusCode2[StatusCode2["OK"] = 1] = "OK";
+  StatusCode2[StatusCode2["InvalidApiKey"] = 100] = "InvalidApiKey";
+  StatusCode2[StatusCode2["ObjectNotFound"] = 101] = "ObjectNotFound";
+  StatusCode2[StatusCode2["UrlFormatError"] = 102] = "UrlFormatError";
+  StatusCode2[StatusCode2["JsonpCallbackMissing"] = 103] = "JsonpCallbackMissing";
+  StatusCode2[StatusCode2["FilterError"] = 104] = "FilterError";
+  StatusCode2[StatusCode2["SubscriberOnlyVideo"] = 105] = "SubscriberOnlyVideo";
+  return StatusCode2;
+})(StatusCode || {});
+var BaseError = class extends HttpClientError {
+  constructor(details) {
+    super(details.message);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.help = details.help;
+  }
+};
+
+// src/errors/generic-error.ts
+var GenericError = class extends BaseError {
+  constructor(message) {
+    super({
+      message: `An unexpected error occurred: ${message || "Unknown Error"}`,
+      help: "Please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+
+// src/errors/custom-error.ts
+var customError = (error) => {
+  if (error instanceof Error) {
+    return new GenericError(error.message);
+  }
+  return new GenericError();
+};
+
+// src/errors/filter-error.ts
+var ComicVineFilterError = class extends BaseError {
+  constructor() {
+    super({
+      message: "There was a problem trying to filter the API results",
+      help: "Please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+
+// src/errors/generic-request-error.ts
+var ComicVineGenericError = class extends BaseError {
+  constructor(message) {
+    super({
+      message: `Request to comic vine failed: ${message != null ? message : "Unknown Error"}`,
+      help: "Please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+var ComicVineGenericRequestError = class extends ComicVineGenericError {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/errors/jsonp-callback-missing-error.ts
+var ComicJsonpCallbackMissingError = class extends BaseError {
+  constructor() {
+    super({
+      message: "JSONP format requires a callback",
+      help: "This library does not use JSONP, please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+
+// src/errors/object-not-found-error.ts
+var ComicVineObjectNotFoundError = class extends BaseError {
+  constructor() {
+    super({
+      message: "The requested resource could not be found in the Comic Vine API",
+      help: "Ensure you have used a valid resource Id"
+    });
+  }
+};
+
+// src/errors/options-validation-error.ts
+var OptionsValidationError = class extends BaseError {
+  constructor(path, message) {
+    super({
+      message: `Property: ${path.join(".")}, Problem: ${message}`,
+      help: "If the error message does not provide enough information or you believe there is a bug, please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+
+// src/errors/subscriber-only-error.ts
+var ComicVineSubscriberOnlyError = class extends BaseError {
+  constructor() {
+    super({
+      message: "The requested video is for subscribers only",
+      help: "Subscriber videos are part of a paid service, if you wish to upgrade you can do so here: https://comicvine.gamespot.com/upgrade/"
+    });
+  }
+};
+
+// src/errors/unauthorized-error.ts
+var ComicVineUnauthorizedError = class extends BaseError {
+  constructor() {
+    super({
+      message: "Unauthorized response received when calling the Comic Vine API",
+      help: "Ensure you have a valid API key, you can get one from: https://comicvine.gamespot.com/api/"
+    });
+  }
+};
+
+// src/errors/url-format-error.ts
+var ComicVineUrlFormatError = class extends BaseError {
+  constructor() {
+    super({
+      message: "The url for the request was not in the correct format",
+      help: "Please open a Github issue with steps to reproduce: https://github.com/AllyMurray/comic-vine/issues"
+    });
+  }
+};
+
+// src/utils/is-object.ts
+var isObject = (maybeObject) => maybeObject === Object(maybeObject) && !Array.isArray(maybeObject) && typeof maybeObject !== "function";
+
+// src/utils/case-converter.ts
+var toCamelCase = (str) => {
+  return str.replace(/([-_][a-z])/gi, ($1) => {
+    return $1.toUpperCase().replace("-", "").replace("_", "");
+  });
+};
+var toSnakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+var convertCase = (caseConverter, object) => {
+  if (isObject(object)) {
+    const newObject = {};
+    Object.keys(object).forEach((key) => {
+      newObject[caseConverter(key)] = convertCase(
+        caseConverter,
+        object[key]
+      );
+    });
+    return newObject;
+  } else if (Array.isArray(object)) {
+    return object.map(
+      (arrayElement) => convertCase(caseConverter, arrayElement)
+    );
+  }
+  return object;
+};
+var convertSnakeCaseToCamelCase = (object) => {
+  return convertCase(toCamelCase, object);
+};
+var convertCamelCaseToSnakeCase = (object) => {
+  return convertCase(toSnakeCase, object);
+};
+
+// src/http-client/hooks.ts
+function comicVineResponseTransformer(data) {
+  return convertSnakeCaseToCamelCase(data);
+}
+function comicVineResponseHandler(data) {
+  if (data !== null && typeof data === "object" && "statusCode" in data && typeof data.statusCode === "number") {
+    const statusCode = data.statusCode;
+    switch (statusCode) {
+      case 104 /* FilterError */:
+        throw new ComicVineFilterError();
+      case 103 /* JsonpCallbackMissing */:
+        throw new ComicJsonpCallbackMissingError();
+      case 101 /* ObjectNotFound */:
+        throw new ComicVineObjectNotFoundError();
+      case 105 /* SubscriberOnlyVideo */:
+        throw new ComicVineSubscriberOnlyError();
+      case 102 /* UrlFormatError */:
+        throw new ComicVineUrlFormatError();
+    }
+  }
+  return data;
+}
+function comicVineErrorHandler(context) {
+  if (context.response.status === 401) {
+    return new ComicVineUnauthorizedError();
+  }
+  const bodyMessage = typeof context.response.data === "object" && context.response.data !== null ? context.response.data.message : void 0;
+  const message = bodyMessage ? `${context.message}, ${bodyMessage}` : context.message;
+  return new ComicVineGenericRequestError(message);
+}
+
+// src/resources/resource-list.ts
+var resource_list_exports = {};
+__export(resource_list_exports, {
+  Character: () => Character,
+  Concept: () => Concept,
+  Episode: () => Episode,
+  Issue: () => Issue,
+  Location: () => Location,
+  Movie: () => Movie,
+  Origin: () => Origin,
+  Person: () => Person,
+  Power: () => Power,
+  Promo: () => Promo,
+  Publisher: () => Publisher,
+  Series: () => Series,
+  StoryArc: () => StoryArc,
+  Team: () => Team,
+  Thing: () => Thing,
+  Video: () => Video,
+  VideoCategory: () => VideoCategory,
+  VideoType: () => VideoType,
+  Volume: () => Volume
+});
+
+// src/resources/base-resource.ts
+var BaseResource = class {
+  constructor(httpClient, urlBuilder) {
+    this.httpClient = httpClient;
+    this.urlBuilder = urlBuilder;
+  }
+  retrieve(id, options2) {
+    return __async(this, null, function* () {
+      const url = this.urlBuilder.retrieve(this.resourceType, id, options2);
+      options2 == null ? void 0 : options2.fieldList;
+      const response = yield this.httpClient.get(url, {
+        priority: options2 == null ? void 0 : options2.priority
+      });
+      return response.results;
+    });
+  }
+  fetchPage(options2) {
+    return __async(this, null, function* () {
+      const url = this.urlBuilder.list(this.resourceType, options2);
+      options2 == null ? void 0 : options2.fieldList;
+      const response = yield this.httpClient.get(
+        url,
+        {
+          priority: options2 == null ? void 0 : options2.priority
+        }
+      );
+      return {
+        limit: response.limit,
+        numberOfPageResults: response.numberOfPageResults,
+        numberOfTotalResults: response.numberOfTotalResults,
+        offset: response.offset,
+        data: response.results
+      };
+    });
+  }
+  list(options2) {
+    const fetchPage = (opts) => this.fetchPage.call(this, opts);
+    const fetchPagePromise = fetchPage(options2);
+    const asyncIterator = {
+      [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, null, function* () {
+          var _a2;
+          const defaultPageSize = 100;
+          const limit = (_a2 = options2 == null ? void 0 : options2.limit) != null ? _a2 : defaultPageSize;
+          let page = (options2 == null ? void 0 : options2.offset) ? options2.offset / limit + 1 : 1;
+          let hasMoreResults = true;
+          let response = yield new __await(fetchPagePromise);
+          do {
+            for (const resource of response.data) {
+              yield resource;
+            }
+            hasMoreResults = response.limit + response.offset < response.numberOfTotalResults;
+            if (hasMoreResults) {
+              response = yield new __await(fetchPage({
+                limit,
+                offset: response.numberOfPageResults * page++
+              }));
+            }
+          } while (hasMoreResults);
+        });
+      }
+    };
+    const promiseWithAsyncIterator = Object.assign(
+      fetchPagePromise,
+      asyncIterator
+    );
+    return promiseWithAsyncIterator;
+  }
+};
+
+// src/resources/resource-type.ts
+var ResourceType = /* @__PURE__ */ ((ResourceType3) => {
+  ResourceType3[ResourceType3["Character"] = 4005] = "Character";
+  ResourceType3[ResourceType3["Concept"] = 4015] = "Concept";
+  ResourceType3[ResourceType3["Episode"] = 4070] = "Episode";
+  ResourceType3[ResourceType3["Issue"] = 4e3] = "Issue";
+  ResourceType3[ResourceType3["Location"] = 4020] = "Location";
+  ResourceType3[ResourceType3["Movie"] = 4025] = "Movie";
+  ResourceType3[ResourceType3["Origin"] = 4030] = "Origin";
+  ResourceType3[ResourceType3["Person"] = 4040] = "Person";
+  ResourceType3[ResourceType3["Power"] = 4035] = "Power";
+  ResourceType3[ResourceType3["Promo"] = 1700] = "Promo";
+  ResourceType3[ResourceType3["Publisher"] = 4010] = "Publisher";
+  ResourceType3[ResourceType3["Series"] = 4075] = "Series";
+  ResourceType3[ResourceType3["StoryArc"] = 4045] = "StoryArc";
+  ResourceType3[ResourceType3["Team"] = 4060] = "Team";
+  ResourceType3[ResourceType3["Thing"] = 4055] = "Thing";
+  ResourceType3[ResourceType3["Video"] = 2300] = "Video";
+  ResourceType3[ResourceType3["VideoCategory"] = 2320] = "VideoCategory";
+  ResourceType3[ResourceType3["VideoType"] = 2320] = "VideoType";
+  ResourceType3[ResourceType3["Volume"] = 4050] = "Volume";
+  return ResourceType3;
+})(ResourceType || {});
+
+// src/resources/character/character.ts
+var Character = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4005 /* Character */;
+  }
+};
+
+// src/resources/concept/concept.ts
+var Concept = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4015 /* Concept */;
+  }
+};
+
+// src/resources/episode/episode.ts
+var Episode = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4070 /* Episode */;
+  }
+};
+
+// src/resources/issue/issue.ts
+var Issue = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4e3 /* Issue */;
+  }
+};
+
+// src/resources/location/location.ts
+var Location = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4020 /* Location */;
+  }
+};
+
+// src/resources/movie/movie.ts
+var Movie = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4025 /* Movie */;
+  }
+};
+
+// src/resources/origin/origin.ts
+var Origin = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4030 /* Origin */;
+  }
+};
+
+// src/resources/person/person.ts
+var Person = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4040 /* Person */;
+  }
+};
+
+// src/resources/power/power.ts
+var Power = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4035 /* Power */;
+  }
+};
+
+// src/resources/promo/promo.ts
+var Promo = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 1700 /* Promo */;
+  }
+};
+
+// src/resources/publisher/publisher.ts
+var Publisher = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4010 /* Publisher */;
+  }
+};
+
+// src/resources/series/series.ts
+var Series = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4075 /* Series */;
+  }
+};
+
+// src/resources/story-arc/story-arc.ts
+var StoryArc = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4045 /* StoryArc */;
+  }
+};
+
+// src/resources/team/team.ts
+var Team = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4060 /* Team */;
+  }
+};
+
+// src/resources/thing/thing.ts
+var Thing = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4055 /* Thing */;
+  }
+};
+
+// src/resources/video/video.ts
+var Video = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 2300 /* Video */;
+  }
+};
+
+// src/resources/video-category/video-category.ts
+var VideoCategory = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 2320 /* VideoCategory */;
+  }
+};
+
+// src/resources/video-type/video-type.ts
+var VideoType = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 2320 /* VideoType */;
+  }
+};
+
+// src/resources/volume/volume.ts
+var Volume = class extends BaseResource {
+  constructor() {
+    super(...arguments);
+    this.resourceType = 4050 /* Volume */;
+  }
+};
+
+// src/resources/resource-factory.ts
+var ResourceFactory = class {
+  constructor(httpClient, urlBuilder) {
+    this.httpClient = httpClient;
+    this.urlBuilder = urlBuilder;
+    this._resources = __spreadValues({}, resource_list_exports);
+  }
+  create(name) {
+    if (!this._resources[name]) {
+      throw new Error(`${name} resource not implemented`);
+    }
+    const ResourceClass = this._resources[name];
+    return new ResourceClass(this.httpClient, this.urlBuilder);
+  }
+};
+
+// src/resources/resource-map.ts
+var resourceMap = /* @__PURE__ */ new Map([
+  [4005 /* Character */, { detailName: "character", listName: "characters" }],
+  [4015 /* Concept */, { detailName: "concept", listName: "concepts" }],
+  [4070 /* Episode */, { detailName: "episode", listName: "episodes" }],
+  [4e3 /* Issue */, { detailName: "issue", listName: "issues" }],
+  [4020 /* Location */, { detailName: "location", listName: "locations" }],
+  [4025 /* Movie */, { detailName: "movie", listName: "movies" }],
+  [4030 /* Origin */, { detailName: "origin", listName: "origins" }],
+  [4040 /* Person */, { detailName: "person", listName: "people" }],
+  [4035 /* Power */, { detailName: "power", listName: "powers" }],
+  [1700 /* Promo */, { detailName: "promo", listName: "promos" }],
+  [4010 /* Publisher */, { detailName: "publisher", listName: "publishers" }],
+  [4075 /* Series */, { detailName: "series", listName: "series_list" }],
+  [4045 /* StoryArc */, { detailName: "story_arc", listName: "story_arcs" }],
+  [4060 /* Team */, { detailName: "team", listName: "teams" }],
+  [4055 /* Thing */, { detailName: "object", listName: "objects" }],
+  [2300 /* Video */, { detailName: "video", listName: "videos" }],
+  [
+    2320 /* VideoCategory */,
+    { detailName: "video_category", listName: "video_categories" }
+  ],
+  [
+    2320 /* VideoType */,
+    { detailName: "video_type", listName: "video_types" }
+  ],
+  [4050 /* Volume */, { detailName: "volume", listName: "volumes" }]
+]);
+var getResource = (resourceType) => {
+  const resource = resourceMap.get(resourceType);
+  if (!resource) {
+    throw new Error(`Resource type (${resourceType}) not found`);
+  }
+  return resource;
+};
+
+// src/http-client/url-builder.ts
+var isDefined = (value) => {
+  return value != null;
+};
+var UrlBuilder = class {
+  constructor(apiKey, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  getParam(key, value) {
+    if (value) {
+      return { name: toSnakeCase(key), value };
+    }
+    return void 0;
+  }
+  getFormatParm() {
+    return { name: "format", value: `json` };
+  }
+  getApiKeyParm() {
+    return { name: "api_key", value: this.apiKey };
+  }
+  getSortParam(sort) {
+    if (sort) {
+      return { name: "sort", value: `${sort.field}:${sort.direction}` };
+    }
+    return void 0;
+  }
+  getLimitParam(limit) {
+    if (limit) {
+      return this.getParam("limit", limit);
+    }
+    return void 0;
+  }
+  getOffsetParam(offset) {
+    if (offset) {
+      return this.getParam("offset", offset);
+    }
+    return void 0;
+  }
+  getFieldListParams(fieldList) {
+    if (fieldList) {
+      return {
+        name: "field_list",
+        value: fieldList.map((field) => toSnakeCase(String(field))).join(",")
+      };
+    }
+    return void 0;
+  }
+  getFilterParams(filter) {
+    if (filter) {
+      const snakeCaseFilter = convertCamelCaseToSnakeCase(filter);
+      const filterParams = Object.entries(snakeCaseFilter).map(
+        ([key, value]) => `${key}:${value}`
+      );
+      return { name: "filter", value: filterParams.join(",") };
+    }
+    return void 0;
+  }
+  buildUrl(urlInput, queryParams) {
+    const url = new URL(urlInput, this.baseUrl);
+    const urlSearchParams = new URLSearchParams(
+      queryParams.filter(isDefined).map((param) => [param.name, param.value.toString()])
+    );
+    url.search = urlSearchParams.toString();
+    return url.toString();
+  }
+  /**
+   * @param resourceType A unique identifier for the resource type
+   * @param id A unique identifier for the resource
+   * @returns A url for requesting the resource
+   * @example https://comicvine.gamespot.com/api/issue/4000-719442?format=json&api_key=123abc
+   */
+  retrieve(resourceType, id, options2) {
+    const resource = getResource(resourceType);
+    const urlInput = `${resource.detailName}/${resourceType}-${id}`;
+    const queryParams = [
+      this.getFormatParm(),
+      this.getApiKeyParm(),
+      this.getFieldListParams(options2 == null ? void 0 : options2.fieldList)
+    ];
+    return this.buildUrl(urlInput, queryParams);
+  }
+  /**
+   * @param resourceType A unique identifier for the resource type
+   * @returns A url for requesting a list of resources
+   * @example https://comicvine.gamespot.com/api/issues?format=json&api_key=123abc
+   */
+  list(resourceType, options2) {
+    const urlInput = getResource(resourceType).listName;
+    const queryParams = [
+      this.getFormatParm(),
+      this.getApiKeyParm(),
+      this.getLimitParam(options2 == null ? void 0 : options2.limit),
+      this.getOffsetParam(options2 == null ? void 0 : options2.offset),
+      this.getSortParam(options2 == null ? void 0 : options2.sort),
+      this.getFieldListParams(options2 == null ? void 0 : options2.fieldList),
+      this.getFilterParams(options2 == null ? void 0 : options2.filter)
+    ];
+    return this.buildUrl(urlInput, queryParams);
+  }
+};
+var options = z.object({
+  /**
+   * The base url for the Comic Vine API.
+   * This could be used to set a proxy when using the library in a browser.
+   * It also ensures that if the comic vine url was to change it wouldn't be a breaking change to the library.
+   * @default https://comicvine.gamespot.com/api/
+   */
+  baseUrl: z.string().url().optional().default("https://comicvine.gamespot.com/api/")
+});
+var loadOptions = (userOptions) => {
+  try {
+    return options.parse(userOptions != null ? userOptions : {});
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const validationError = error.issues[0];
+      if (validationError) {
+        throw new OptionsValidationError(
+          validationError.path,
+          validationError.message
+        );
+      }
+      throw new OptionsValidationError([], "Unknown validation error");
+    }
+    throw customError(error);
+  }
+};
+
+// src/comic-vine.ts
+function classNameToPropertyName(className) {
+  if (!className) {
+    return "";
+  }
+  return className.charAt(0).toLowerCase() + className.slice(1);
+}
+var resourceMappings = Object.values(ResourceType).filter((value) => typeof value === "number").map((resourceType) => getResource(resourceType));
+var canonicalRateLimitResourceNames = /* @__PURE__ */ new Map();
+for (const { detailName, listName } of resourceMappings) {
+  canonicalRateLimitResourceNames.set(detailName, listName);
+  canonicalRateLimitResourceNames.set(listName, listName);
+  canonicalRateLimitResourceNames.set(toSnakeCase(detailName), listName);
+  canonicalRateLimitResourceNames.set(toSnakeCase(listName), listName);
+}
+function normalizeRateLimitResourceName(resourceName) {
+  var _a;
+  return (_a = canonicalRateLimitResourceNames.get(toSnakeCase(resourceName))) != null ? _a : resourceName;
+}
+function inferComicVineRateLimitResource(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    const segments = pathname.split("/").filter(Boolean);
+    const apiIndex = segments.indexOf("api");
+    const endpoint = apiIndex >= 0 ? segments[apiIndex + 1] : segments[0];
+    if (!endpoint) {
+      return "unknown";
+    }
+    return normalizeRateLimitResourceName(endpoint);
+  } catch (e) {
+    return "unknown";
+  }
+}
+var ComicVine = class {
+  /**
+   * Create a new ComicVine client
+   * @param options - Configuration options for the client
+   */
+  constructor(options2) {
+    this.resourceCache = /* @__PURE__ */ new Map();
+    const { apiKey, baseUrl, stores = {}, client = {} } = options2;
+    const _options = loadOptions({ baseUrl });
+    const httpClient = new HttpClient({
+      name: "comic-vine-sdk",
+      cache: stores.cache ? {
+        store: stores.cache,
+        ttl: client.defaultCacheTTL
+      } : void 0,
+      dedupe: stores.dedupe,
+      rateLimit: stores.rateLimit ? {
+        store: stores.rateLimit,
+        throw: client.throwOnRateLimit,
+        maxWaitTime: client.maxWaitTime
+      } : void 0,
+      responseTransformer: comicVineResponseTransformer,
+      responseHandler: comicVineResponseHandler,
+      errorHandler: comicVineErrorHandler,
+      resourceKeyResolver: inferComicVineRateLimitResource
+    });
+    const urlBuilder = new UrlBuilder(apiKey, _options.baseUrl);
+    this.resourceFactory = new ResourceFactory(httpClient, urlBuilder);
+    this.stores = stores;
+    this.resourceNames = Object.keys(resource_list_exports);
+    return new Proxy(this, {
+      get(target, prop) {
+        if (typeof prop === "string" && target.isResourceProperty(prop)) {
+          return target.getResource(prop);
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  }
+  isResourceProperty(prop) {
+    const className = prop.charAt(0).toUpperCase() + prop.slice(1);
+    return this.resourceNames.includes(className);
+  }
+  getResource(propertyName) {
+    if (!this.resourceCache.has(propertyName)) {
+      const className = propertyName.charAt(0).toUpperCase() + propertyName.slice(1);
+      try {
+        const resource = this.resourceFactory.create(
+          className
+        );
+        this.resourceCache.set(propertyName, resource);
+      } catch (error) {
+        throw new Error(`Failed to create resource '${className}': ${error}`);
+      }
+    }
+    return this.resourceCache.get(propertyName);
+  }
+  getAvailableResources() {
+    return this.resourceNames.map((name) => classNameToPropertyName(name));
+  }
+  hasResource(resourceName) {
+    return this.isResourceProperty(resourceName);
+  }
+  getResourceByName(resourceName) {
+    if (!this.isResourceProperty(resourceName)) {
+      return void 0;
+    }
+    return this.getResource(resourceName);
+  }
+  isResourceLoaded(resourceName) {
+    return this.resourceCache.has(resourceName);
+  }
+  getCacheStats() {
+    const total = this.resourceNames.length;
+    const loaded = this.resourceCache.size;
+    const loadedResources = Array.from(this.resourceCache.keys());
+    return { total, loaded, loadedResources };
+  }
+  clearCache() {
+    return __async(this, null, function* () {
+      if (this.stores.cache) {
+        yield this.stores.cache.clear();
+      }
+    });
+  }
+  getRateLimitStatus(resourceName) {
+    return __async(this, null, function* () {
+      if (this.stores.rateLimit) {
+        return this.stores.rateLimit.getStatus(
+          normalizeRateLimitResourceName(resourceName)
+        );
+      }
+      return null;
+    });
+  }
+  resetRateLimit(resourceName) {
+    return __async(this, null, function* () {
+      if (this.stores.rateLimit) {
+        yield this.stores.rateLimit.reset(
+          normalizeRateLimitResourceName(resourceName)
+        );
+      }
+    });
+  }
+};
+
+// src/index.ts
+var src_default = ComicVine;
+
+export { ComicJsonpCallbackMissingError, ComicVine, ComicVineFilterError, ComicVineGenericError, ComicVineGenericRequestError, ComicVineObjectNotFoundError, ComicVineSubscriberOnlyError, ComicVineUnauthorizedError, ComicVineUrlFormatError, GenericError, OptionsValidationError, StatusCode, customError, src_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map