comic-vine-sdk 1.3.2 → 2.0.1

package/lib/index.cjs

@@ -0,0 +1,1462 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ 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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+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, call, wait, clear) => it[k] = (x) => (call = new Promise((yes, no, run) => (run = () => resume(k, x, yes, no), q ? q.then(run) : run())), clear = () => q === wait && (q = 0), q = wait = call.then(clear, clear), call), q, 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;
+var init_status_code = __esm({
+  "src/http-client/status-code.ts"() {
+    "use strict";
+    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 || {});
+  }
+});
+
+// src/errors/base-error.ts
+function hasCaptureStackTrace(errorConstructor) {
+  return "captureStackTrace" in errorConstructor && typeof Reflect.get(errorConstructor, "captureStackTrace") === "function";
+}
+var import_core, BaseError;
+var init_base_error = __esm({
+  "src/errors/base-error.ts"() {
+    "use strict";
+    import_core = require("@http-client-toolkit/core");
+    BaseError = class extends import_core.HttpClientError {
+      constructor(details) {
+        super(details.message);
+        this.name = this.constructor.name;
+        if (hasCaptureStackTrace(Error)) {
+          Error.captureStackTrace(this, new.target);
+        }
+        this.help = details.help;
+      }
+    };
+  }
+});
+
+// src/errors/generic-error.ts
+var GenericError;
+var init_generic_error = __esm({
+  "src/errors/generic-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_custom_error = __esm({
+  "src/errors/custom-error.ts"() {
+    "use strict";
+    init_generic_error();
+    customError = (error) => {
+      if (error instanceof Error) {
+        return new GenericError(error.message);
+      }
+      return new GenericError();
+    };
+  }
+});
+
+// src/errors/filter-error.ts
+var ComicVineFilterError;
+var init_filter_error = __esm({
+  "src/errors/filter-error.ts"() {
+    "use strict";
+    init_base_error();
+    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, ComicVineGenericRequestError;
+var init_generic_request_error = __esm({
+  "src/errors/generic-request-error.ts"() {
+    "use strict";
+    init_base_error();
+    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"
+        });
+      }
+    };
+    ComicVineGenericRequestError = class extends ComicVineGenericError {
+      constructor(message) {
+        super(message);
+      }
+    };
+  }
+});
+
+// src/errors/jsonp-callback-missing-error.ts
+var ComicJsonpCallbackMissingError;
+var init_jsonp_callback_missing_error = __esm({
+  "src/errors/jsonp-callback-missing-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_object_not_found_error = __esm({
+  "src/errors/object-not-found-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_options_validation_error = __esm({
+  "src/errors/options-validation-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_subscriber_only_error = __esm({
+  "src/errors/subscriber-only-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_unauthorized_error = __esm({
+  "src/errors/unauthorized-error.ts"() {
+    "use strict";
+    init_base_error();
+    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;
+var init_url_format_error = __esm({
+  "src/errors/url-format-error.ts"() {
+    "use strict";
+    init_base_error();
+    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/errors/index.ts
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    "use strict";
+    init_custom_error();
+    init_filter_error();
+    init_generic_error();
+    init_generic_request_error();
+    init_jsonp_callback_missing_error();
+    init_object_not_found_error();
+    init_options_validation_error();
+    init_subscriber_only_error();
+    init_unauthorized_error();
+    init_url_format_error();
+  }
+});
+
+// src/utils/is-object.ts
+var isObject;
+var init_is_object = __esm({
+  "src/utils/is-object.ts"() {
+    "use strict";
+    isObject = (maybeObject) => maybeObject === Object(maybeObject) && !Array.isArray(maybeObject) && typeof maybeObject !== "function";
+  }
+});
+
+// src/utils/case-converter.ts
+var toCamelCase, toSnakeCase, convertCase, convertSnakeCaseToCamelCase, convertCamelCaseToSnakeCase;
+var init_case_converter = __esm({
+  "src/utils/case-converter.ts"() {
+    "use strict";
+    init_is_object();
+    toCamelCase = (str) => {
+      return str.replace(/([-_][a-z])/gi, ($1) => {
+        return $1.toUpperCase().replace("-", "").replace("_", "");
+      });
+    };
+    toSnakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    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;
+    };
+    convertSnakeCaseToCamelCase = (object) => {
+      return convertCase(toCamelCase, object);
+    };
+    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);
+}
+var init_hooks = __esm({
+  "src/http-client/hooks.ts"() {
+    "use strict";
+    init_errors();
+    init_case_converter();
+  }
+});
+
+// src/resources/base-resource.ts
+var BaseResource;
+var init_base_resource = __esm({
+  "src/resources/base-resource.ts"() {
+    "use strict";
+    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);
+          const _fieldList = 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);
+          const _fieldList = 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 response = yield new __await(fetchPagePromise);
+              while (true) {
+                for (const resource of response.data) {
+                  yield resource;
+                }
+                if (response.limit + response.offset >= response.numberOfTotalResults) {
+                  break;
+                }
+                response = yield new __await(fetchPage({
+                  limit,
+                  offset: response.numberOfPageResults * page++
+                }));
+              }
+            });
+          }
+        };
+        const promiseWithAsyncIterator = Object.assign(
+          fetchPagePromise,
+          asyncIterator
+        );
+        return promiseWithAsyncIterator;
+      }
+    };
+  }
+});
+
+// src/resources/resource-type.ts
+var ResourceType;
+var init_resource_type = __esm({
+  "src/resources/resource-type.ts"() {
+    "use strict";
+    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;
+var init_character = __esm({
+  "src/resources/character/character.ts"() {
+    "use strict";
+    init_base_resource();
+    Character = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4005 /* Character */;
+      }
+    };
+  }
+});
+
+// src/resources/character/index.ts
+var init_character2 = __esm({
+  "src/resources/character/index.ts"() {
+    "use strict";
+    init_character();
+  }
+});
+
+// src/resources/concept/concept.ts
+var Concept;
+var init_concept = __esm({
+  "src/resources/concept/concept.ts"() {
+    "use strict";
+    init_base_resource();
+    Concept = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4015 /* Concept */;
+      }
+    };
+  }
+});
+
+// src/resources/concept/index.ts
+var init_concept2 = __esm({
+  "src/resources/concept/index.ts"() {
+    "use strict";
+    init_concept();
+  }
+});
+
+// src/resources/episode/episode.ts
+var Episode;
+var init_episode = __esm({
+  "src/resources/episode/episode.ts"() {
+    "use strict";
+    init_base_resource();
+    Episode = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4070 /* Episode */;
+      }
+    };
+  }
+});
+
+// src/resources/episode/index.ts
+var init_episode2 = __esm({
+  "src/resources/episode/index.ts"() {
+    "use strict";
+    init_episode();
+  }
+});
+
+// src/resources/issue/issue.ts
+var Issue;
+var init_issue = __esm({
+  "src/resources/issue/issue.ts"() {
+    "use strict";
+    init_base_resource();
+    Issue = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4e3 /* Issue */;
+      }
+    };
+  }
+});
+
+// src/resources/issue/index.ts
+var init_issue2 = __esm({
+  "src/resources/issue/index.ts"() {
+    "use strict";
+    init_issue();
+  }
+});
+
+// src/resources/location/location.ts
+var Location;
+var init_location = __esm({
+  "src/resources/location/location.ts"() {
+    "use strict";
+    init_base_resource();
+    Location = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4020 /* Location */;
+      }
+    };
+  }
+});
+
+// src/resources/location/index.ts
+var init_location2 = __esm({
+  "src/resources/location/index.ts"() {
+    "use strict";
+    init_location();
+  }
+});
+
+// src/resources/movie/movie.ts
+var Movie;
+var init_movie = __esm({
+  "src/resources/movie/movie.ts"() {
+    "use strict";
+    init_base_resource();
+    Movie = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4025 /* Movie */;
+      }
+    };
+  }
+});
+
+// src/resources/movie/index.ts
+var init_movie2 = __esm({
+  "src/resources/movie/index.ts"() {
+    "use strict";
+    init_movie();
+  }
+});
+
+// src/resources/origin/origin.ts
+var Origin;
+var init_origin = __esm({
+  "src/resources/origin/origin.ts"() {
+    "use strict";
+    init_base_resource();
+    Origin = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4030 /* Origin */;
+      }
+    };
+  }
+});
+
+// src/resources/origin/index.ts
+var init_origin2 = __esm({
+  "src/resources/origin/index.ts"() {
+    "use strict";
+    init_origin();
+  }
+});
+
+// src/resources/person/person.ts
+var Person;
+var init_person = __esm({
+  "src/resources/person/person.ts"() {
+    "use strict";
+    init_base_resource();
+    Person = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4040 /* Person */;
+      }
+    };
+  }
+});
+
+// src/resources/person/index.ts
+var init_person2 = __esm({
+  "src/resources/person/index.ts"() {
+    "use strict";
+    init_person();
+  }
+});
+
+// src/resources/power/power.ts
+var Power;
+var init_power = __esm({
+  "src/resources/power/power.ts"() {
+    "use strict";
+    init_base_resource();
+    Power = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4035 /* Power */;
+      }
+    };
+  }
+});
+
+// src/resources/power/index.ts
+var init_power2 = __esm({
+  "src/resources/power/index.ts"() {
+    "use strict";
+    init_power();
+  }
+});
+
+// src/resources/promo/promo.ts
+var Promo;
+var init_promo = __esm({
+  "src/resources/promo/promo.ts"() {
+    "use strict";
+    init_base_resource();
+    Promo = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 1700 /* Promo */;
+      }
+    };
+  }
+});
+
+// src/resources/promo/index.ts
+var init_promo2 = __esm({
+  "src/resources/promo/index.ts"() {
+    "use strict";
+    init_promo();
+  }
+});
+
+// src/resources/publisher/publisher.ts
+var Publisher;
+var init_publisher = __esm({
+  "src/resources/publisher/publisher.ts"() {
+    "use strict";
+    init_base_resource();
+    Publisher = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4010 /* Publisher */;
+      }
+    };
+  }
+});
+
+// src/resources/publisher/index.ts
+var init_publisher2 = __esm({
+  "src/resources/publisher/index.ts"() {
+    "use strict";
+    init_publisher();
+  }
+});
+
+// src/resources/series/series.ts
+var Series;
+var init_series = __esm({
+  "src/resources/series/series.ts"() {
+    "use strict";
+    init_base_resource();
+    Series = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4075 /* Series */;
+      }
+    };
+  }
+});
+
+// src/resources/series/index.ts
+var init_series2 = __esm({
+  "src/resources/series/index.ts"() {
+    "use strict";
+    init_series();
+  }
+});
+
+// src/resources/story-arc/story-arc.ts
+var StoryArc;
+var init_story_arc = __esm({
+  "src/resources/story-arc/story-arc.ts"() {
+    "use strict";
+    init_base_resource();
+    StoryArc = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4045 /* StoryArc */;
+      }
+    };
+  }
+});
+
+// src/resources/story-arc/index.ts
+var init_story_arc2 = __esm({
+  "src/resources/story-arc/index.ts"() {
+    "use strict";
+    init_story_arc();
+  }
+});
+
+// src/resources/team/team.ts
+var Team;
+var init_team = __esm({
+  "src/resources/team/team.ts"() {
+    "use strict";
+    init_base_resource();
+    Team = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4060 /* Team */;
+      }
+    };
+  }
+});
+
+// src/resources/team/index.ts
+var init_team2 = __esm({
+  "src/resources/team/index.ts"() {
+    "use strict";
+    init_team();
+  }
+});
+
+// src/resources/thing/thing.ts
+var Thing;
+var init_thing = __esm({
+  "src/resources/thing/thing.ts"() {
+    "use strict";
+    init_base_resource();
+    Thing = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4055 /* Thing */;
+      }
+    };
+  }
+});
+
+// src/resources/thing/index.ts
+var init_thing2 = __esm({
+  "src/resources/thing/index.ts"() {
+    "use strict";
+    init_thing();
+  }
+});
+
+// src/resources/video/video.ts
+var Video;
+var init_video = __esm({
+  "src/resources/video/video.ts"() {
+    "use strict";
+    init_base_resource();
+    Video = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 2300 /* Video */;
+      }
+    };
+  }
+});
+
+// src/resources/video/index.ts
+var init_video2 = __esm({
+  "src/resources/video/index.ts"() {
+    "use strict";
+    init_video();
+  }
+});
+
+// src/resources/video-category/video-category.ts
+var VideoCategory;
+var init_video_category = __esm({
+  "src/resources/video-category/video-category.ts"() {
+    "use strict";
+    init_base_resource();
+    VideoCategory = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 2320 /* VideoCategory */;
+      }
+    };
+  }
+});
+
+// src/resources/video-category/index.ts
+var init_video_category2 = __esm({
+  "src/resources/video-category/index.ts"() {
+    "use strict";
+    init_video_category();
+  }
+});
+
+// src/resources/video-type/video-type.ts
+var VideoType;
+var init_video_type = __esm({
+  "src/resources/video-type/video-type.ts"() {
+    "use strict";
+    init_base_resource();
+    VideoType = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 2320 /* VideoType */;
+      }
+    };
+  }
+});
+
+// src/resources/video-type/index.ts
+var init_video_type2 = __esm({
+  "src/resources/video-type/index.ts"() {
+    "use strict";
+    init_video_type();
+  }
+});
+
+// src/resources/volume/volume.ts
+var Volume;
+var init_volume = __esm({
+  "src/resources/volume/volume.ts"() {
+    "use strict";
+    init_base_resource();
+    Volume = class extends BaseResource {
+      constructor() {
+        super(...arguments);
+        this.resourceType = 4050 /* Volume */;
+      }
+    };
+  }
+});
+
+// src/resources/volume/index.ts
+var init_volume2 = __esm({
+  "src/resources/volume/index.ts"() {
+    "use strict";
+    init_volume();
+  }
+});
+
+// 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
+});
+var init_resource_list = __esm({
+  "src/resources/resource-list.ts"() {
+    "use strict";
+    init_character2();
+    init_concept2();
+    init_episode2();
+    init_issue2();
+    init_location2();
+    init_movie2();
+    init_origin2();
+    init_person2();
+    init_power2();
+    init_promo2();
+    init_publisher2();
+    init_series2();
+    init_story_arc2();
+    init_team2();
+    init_thing2();
+    init_video2();
+    init_video_category2();
+    init_video_type2();
+    init_volume2();
+  }
+});
+
+// src/resources/resource-factory.ts
+var ResourceFactory;
+var init_resource_factory = __esm({
+  "src/resources/resource-factory.ts"() {
+    "use strict";
+    init_resource_list();
+    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, getResource;
+var init_resource_map = __esm({
+  "src/resources/resource-map.ts"() {
+    "use strict";
+    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" }]
+    ]);
+    getResource = (resourceType) => {
+      const resource = resourceMap.get(resourceType);
+      if (!resource) {
+        throw new Error(`Resource type (${resourceType}) not found`);
+      }
+      return resource;
+    };
+  }
+});
+
+// src/resources/index.ts
+var init_resources = __esm({
+  "src/resources/index.ts"() {
+    "use strict";
+    init_resource_factory();
+    init_resource_map();
+    init_resource_type();
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    "use strict";
+    init_case_converter();
+    init_is_object();
+  }
+});
+
+// src/http-client/url-builder.ts
+var isDefined, UrlBuilder;
+var init_url_builder = __esm({
+  "src/http-client/url-builder.ts"() {
+    "use strict";
+    init_resources();
+    init_utils();
+    isDefined = (value) => {
+      return value != null;
+    };
+    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);
+      }
+    };
+  }
+});
+
+// src/options/index.ts
+var import_zod, options, loadOptions;
+var init_options = __esm({
+  "src/options/index.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    init_errors();
+    options = import_zod.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: import_zod.z.string().url().optional().default("https://comicvine.gamespot.com/api/")
+    });
+    loadOptions = (userOptions) => {
+      try {
+        return options.parse(userOptions != null ? userOptions : {});
+      } catch (error) {
+        if (error instanceof import_zod.ZodError) {
+          const validationError = error.issues[0];
+          if (validationError) {
+            throw new OptionsValidationError(
+              validationError.path.filter(
+                (segment) => typeof segment === "string" || typeof segment === "number"
+              ),
+              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);
+}
+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 import_core2, resourceMappings, canonicalRateLimitResourceNames, ComicVine;
+var init_comic_vine = __esm({
+  "src/comic-vine.ts"() {
+    "use strict";
+    import_core2 = require("@http-client-toolkit/core");
+    init_hooks();
+    init_url_builder();
+    init_options();
+    init_resources();
+    init_resource_list();
+    init_resource_map();
+    init_resource_type();
+    init_utils();
+    resourceMappings = Object.values(ResourceType).filter((value) => typeof value === "number").map((resourceType) => getResource(resourceType));
+    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);
+    }
+    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 import_core2.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}`, {
+              cause: 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/types/http-client.ts
+var init_http_client = __esm({
+  "src/types/http-client.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/iso-date.ts
+var init_iso_date = __esm({
+  "src/types/iso-date.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/pick-filters.ts
+var init_pick_filters = __esm({
+  "src/types/pick-filters.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/request.ts
+var init_request = __esm({
+  "src/types/request.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/response.ts
+var init_response = __esm({
+  "src/types/response.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/url-builder.ts
+var init_url_builder2 = __esm({
+  "src/types/url-builder.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/valueof.ts
+var init_valueof = __esm({
+  "src/types/valueof.ts"() {
+    "use strict";
+  }
+});
+
+// src/types/index.ts
+var init_types = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    init_http_client();
+    init_iso_date();
+    init_pick_filters();
+    init_request();
+    init_response();
+    init_url_builder2();
+    init_valueof();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ComicJsonpCallbackMissingError: () => ComicJsonpCallbackMissingError,
+  ComicVine: () => ComicVine,
+  ComicVineFilterError: () => ComicVineFilterError,
+  ComicVineGenericError: () => ComicVineGenericError,
+  ComicVineGenericRequestError: () => ComicVineGenericRequestError,
+  ComicVineObjectNotFoundError: () => ComicVineObjectNotFoundError,
+  ComicVineSubscriberOnlyError: () => ComicVineSubscriberOnlyError,
+  ComicVineUnauthorizedError: () => ComicVineUnauthorizedError,
+  ComicVineUrlFormatError: () => ComicVineUrlFormatError,
+  GenericError: () => GenericError,
+  OptionsValidationError: () => OptionsValidationError,
+  StatusCode: () => StatusCode,
+  customError: () => customError,
+  default: () => index_default
+});
+var index_default;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_comic_vine();
+    init_status_code();
+    init_errors();
+    init_types();
+    index_default = ComicVine;
+  }
+});
+
+// src/index-wrapper.cjs
+var esm = (init_index(), __toCommonJS(index_exports));
+module.exports = Object.assign(esm.default, esm);
+//# sourceMappingURL=index.cjs.map