bannerify-js 0.0.28 → 0.1.0

package/dist/index.cjs

@@ -18,39 +18,24 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   Bannerify: () => Bannerify,
   createClient: () => createClient
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/errors/HTTPError.js
+// ../../../node_modules/ky/distribution/errors/HTTPError.js
 var HTTPError = class extends Error {
+  response;
+  request;
+  options;
   constructor(response, request, options) {
     const code = response.status || response.status === 0 ? response.status : "";
     const title = response.statusText || "";
     const status = `${code} ${title}`.trim();
     const reason = status ? `status code ${status}` : "an unknown error";
-    super(`Request failed with ${reason}`);
-    Object.defineProperty(this, "response", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "request", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "options", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
+    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
     this.name = "HTTPError";
     this.response = response;
     this.request = request;
@@ -58,25 +43,20 @@ var HTTPError = class extends Error {
   }
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/errors/TimeoutError.js
+// ../../../node_modules/ky/distribution/errors/TimeoutError.js
 var TimeoutError = class extends Error {
+  request;
   constructor(request) {
-    super("Request timed out");
-    Object.defineProperty(this, "request", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
+    super(`Request timed out: ${request.method} ${request.url}`);
     this.name = "TimeoutError";
     this.request = request;
   }
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/is.js
+// ../../../node_modules/ky/distribution/utils/is.js
 var isObject = (value) => value !== null && typeof value === "object";
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/merge.js
+// ../../../node_modules/ky/distribution/utils/merge.js
 var validateAndMerge = (...sources) => {
   for (const source of sources) {
     if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
@@ -98,9 +78,19 @@ var mergeHeaders = (source1 = {}, source2 = {}) => {
   }
   return result;
 };
+function newHookValue(original, incoming, property) {
+  return Object.hasOwn(incoming, property) && incoming[property] === void 0 ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
+}
+var mergeHooks = (original = {}, incoming = {}) => ({
+  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+  afterResponse: newHookValue(original, incoming, "afterResponse"),
+  beforeError: newHookValue(original, incoming, "beforeError")
+});
 var deepMerge = (...sources) => {
   let returnValue = {};
   let headers = {};
+  let hooks = {};
   for (const source of sources) {
     if (Array.isArray(source)) {
       if (!Array.isArray(returnValue)) {
@@ -114,6 +104,10 @@ var deepMerge = (...sources) => {
         }
         returnValue = { ...returnValue, [key]: value };
       }
+      if (isObject(source.hooks)) {
+        hooks = mergeHooks(hooks, source.hooks);
+        returnValue.hooks = hooks;
+      }
       if (isObject(source.headers)) {
         headers = mergeHeaders(headers, source.headers);
         returnValue.headers = headers;
@@ -123,22 +117,29 @@ var deepMerge = (...sources) => {
   return returnValue;
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/core/constants.js
+// ../../../node_modules/ky/distribution/core/constants.js
 var supportsRequestStreams = (() => {
   let duplexAccessed = false;
   let hasContentType = false;
   const supportsReadableStream = typeof globalThis.ReadableStream === "function";
   const supportsRequest = typeof globalThis.Request === "function";
   if (supportsReadableStream && supportsRequest) {
-    hasContentType = new globalThis.Request("https://empty.invalid", {
-      body: new globalThis.ReadableStream(),
-      method: "POST",
-      // @ts-expect-error - Types are outdated.
-      get duplex() {
-        duplexAccessed = true;
-        return "half";
-      }
-    }).headers.has("Content-Type");
+    try {
+      hasContentType = new globalThis.Request("https://empty.invalid", {
+        body: new globalThis.ReadableStream(),
+        method: "POST",
+        // @ts-expect-error - Types are outdated.
+        get duplex() {
+          duplexAccessed = true;
+          return "half";
+        }
+      }).headers.has("Content-Type");
+    } catch (error) {
+      if (error instanceof Error && error.message === "unsupported BodyInit type") {
+        return false;
+      }
+      throw error;
+    }
   }
   return duplexAccessed && !hasContentType;
 })();
@@ -160,6 +161,7 @@ var stop = Symbol("stop");
 var kyOptionKeys = {
   json: true,
   parseJson: true,
+  stringifyJson: true,
   searchParams: true,
   prefixUrl: true,
   retry: true,
@@ -184,10 +186,11 @@ var requestOptionsRegistry = {
   signal: true,
   window: true,
   dispatcher: true,
-  duplex: true
+  duplex: true,
+  priority: true
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/normalize.js
+// ../../../node_modules/ky/distribution/utils/normalize.js
 var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
 var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
 var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
@@ -216,12 +219,11 @@ var normalizeRetryOptions = (retry = {}) => {
   }
   return {
     ...defaultRetryOptions,
-    ...retry,
-    afterStatusCodes: retryAfterStatusCodes
+    ...retry
   };
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/timeout.js
+// ../../../node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init, abortController, options) {
   return new Promise((resolve, reject) => {
     const timeoutId = setTimeout(() => {
@@ -236,7 +238,7 @@ async function timeout(request, init, abortController, options) {
   });
 }
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/delay.js
+// ../../../node_modules/ky/distribution/utils/delay.js
 async function delay(ms, { signal }) {
   return new Promise((resolve, reject) => {
     if (signal) {
@@ -254,7 +256,7 @@ async function delay(ms, { signal }) {
   });
 }
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/utils/options.js
+// ../../../node_modules/ky/distribution/utils/options.js
 var findUnknownOptions = (request, options) => {
   const unknownOptions = {};
   for (const key in options) {
@@ -265,11 +267,11 @@ var findUnknownOptions = (request, options) => {
   return unknownOptions;
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/core/Ky.js
+// ../../../node_modules/ky/distribution/core/Ky.js
 var Ky = class _Ky {
   static create(input, options) {
     const ky2 = new _Ky(input, options);
-    const fn = async () => {
+    const function_ = async () => {
       if (typeof ky2._options.timeout === "number" && ky2._options.timeout > maxSafeTimeout) {
         throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
       }
@@ -301,12 +303,11 @@ var Ky = class _Ky {
       return response;
     };
     const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
-    const result = isRetriableMethod ? ky2._retry(fn) : fn();
+    const result = isRetriableMethod ? ky2._retry(function_) : function_();
     for (const [type, mimeType] of Object.entries(responseTypes)) {
       result[type] = async () => {
         ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
-        const awaitedResult = await result;
-        const response = awaitedResult.clone();
+        const response = await result;
         if (type === "json") {
           if (response.status === 204) {
             return "";
@@ -325,51 +326,24 @@ var Ky = class _Ky {
     }
     return result;
   }
+  request;
+  abortController;
+  _retryCount = 0;
+  _input;
+  _options;
   // eslint-disable-next-line complexity
   constructor(input, options = {}) {
-    Object.defineProperty(this, "request", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "abortController", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "_retryCount", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: 0
-    });
-    Object.defineProperty(this, "_input", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "_options", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
     this._input = input;
     this._options = {
-      // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
-      credentials: this._input.credentials || "same-origin",
       ...options,
       headers: mergeHeaders(this._input.headers, options.headers),
-      hooks: deepMerge({
+      hooks: mergeHooks({
         beforeRequest: [],
         beforeRetry: [],
         beforeError: [],
         afterResponse: []
       }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method),
+      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
       // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
       prefixUrl: String(options.prefixUrl || ""),
       retry: normalizeRetryOptions(options.retry),
@@ -391,17 +365,22 @@ var Ky = class _Ky {
     }
     if (supportsAbortController) {
       this.abortController = new globalThis.AbortController();
-      if (this._options.signal) {
-        const originalSignal = this._options.signal;
-        this._options.signal.addEventListener("abort", () => {
-          this.abortController.abort(originalSignal.reason);
-        });
+      const originalSignal = this._options.signal ?? this._input.signal;
+      if (originalSignal?.aborted) {
+        this.abortController.abort(originalSignal?.reason);
       }
+      originalSignal?.addEventListener("abort", () => {
+        this.abortController.abort(originalSignal.reason);
+      });
       this._options.signal = this.abortController.signal;
     }
     if (supportsRequestStreams) {
       this._options.duplex = "half";
     }
+    if (this._options.json !== void 0) {
+      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
+      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+    }
     this.request = new globalThis.Request(this._input, this._options);
     if (this._options.searchParams) {
       const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
@@ -412,40 +391,33 @@ var Ky = class _Ky {
       }
       this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
     }
-    if (this._options.json !== void 0) {
-      this._options.body = JSON.stringify(this._options.json);
-      this.request.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
-      this.request = new globalThis.Request(this.request, { body: this._options.body });
-    }
   }
   _calculateRetryDelay(error) {
     this._retryCount++;
-    if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
-      if (error instanceof HTTPError) {
-        if (!this._options.retry.statusCodes.includes(error.response.status)) {
-          return 0;
-        }
-        const retryAfter = error.response.headers.get("Retry-After");
-        if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-          let after = Number(retryAfter);
-          if (Number.isNaN(after)) {
-            after = Date.parse(retryAfter) - Date.now();
-          } else {
-            after *= 1e3;
-          }
-          if (this._options.retry.maxRetryAfter !== void 0 && after > this._options.retry.maxRetryAfter) {
-            return 0;
-          }
-          return after;
-        }
-        if (error.response.status === 413) {
-          return 0;
+    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+      throw error;
+    }
+    if (error instanceof HTTPError) {
+      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+        let after = Number(retryAfter) * 1e3;
+        if (Number.isNaN(after)) {
+          after = Date.parse(retryAfter) - Date.now();
+        } else if (after >= Date.parse("2024-01-01")) {
+          after -= Date.now();
         }
+        const max = this._options.retry.maxRetryAfter ?? after;
+        return after < max ? after : max;
+      }
+      if (error.response.status === 413) {
+        throw error;
       }
-      const retryDelay = this._options.retry.delay(this._retryCount);
-      return Math.min(this._options.retry.backoffLimit, retryDelay);
     }
-    return 0;
+    const retryDelay = this._options.retry.delay(this._retryCount);
+    return Math.min(this._options.retry.backoffLimit, retryDelay);
   }
   _decorateResponse(response) {
     if (this._options.parseJson) {
@@ -453,27 +425,27 @@ var Ky = class _Ky {
     }
     return response;
   }
-  async _retry(fn) {
+  async _retry(function_) {
     try {
-      return await fn();
+      return await function_();
     } catch (error) {
       const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (ms !== 0 && this._retryCount > 0) {
-        await delay(ms, { signal: this._options.signal });
-        for (const hook of this._options.hooks.beforeRetry) {
-          const hookResult = await hook({
-            request: this.request,
-            options: this._options,
-            error,
-            retryCount: this._retryCount
-          });
-          if (hookResult === stop) {
-            return;
-          }
+      if (this._retryCount < 1) {
+        throw error;
+      }
+      await delay(ms, { signal: this._options.signal });
+      for (const hook of this._options.hooks.beforeRetry) {
+        const hookResult = await hook({
+          request: this.request,
+          options: this._options,
+          error,
+          retryCount: this._retryCount
+        });
+        if (hookResult === stop) {
+          return;
         }
-        return this._retry(fn);
       }
-      throw error;
+      return this._retry(function_);
     }
   }
   async _fetch() {
@@ -488,10 +460,12 @@ var Ky = class _Ky {
       }
     }
     const nonRequestOptions = findUnknownOptions(this.request, this._options);
+    const mainRequest = this.request;
+    this.request = mainRequest.clone();
     if (this._options.timeout === false) {
-      return this._options.fetch(this.request.clone(), nonRequestOptions);
+      return this._options.fetch(mainRequest, nonRequestOptions);
     }
-    return timeout(this.request.clone(), nonRequestOptions, this.abortController, this._options);
+    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
   }
   /* istanbul ignore next */
   _stream(response, onDownloadProgress) {
@@ -537,14 +511,19 @@ var Ky = class _Ky {
   }
 };
 
-// node_modules/.pnpm/ky@1.1.3/node_modules/ky/distribution/index.js
+// ../../../node_modules/ky/distribution/index.js
 var createInstance = (defaults) => {
   const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
   for (const method of requestMethods) {
     ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
   }
   ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
-  ky2.extend = (newDefaults) => createInstance(validateAndMerge(defaults, newDefaults));
+  ky2.extend = (newDefaults) => {
+    if (typeof newDefaults === "function") {
+      newDefaults = newDefaults(defaults ?? {});
+    }
+    return createInstance(validateAndMerge(defaults, newDefaults));
+  };
   ky2.stop = stop;
   return ky2;
 };
@@ -578,6 +557,24 @@ function getTelemetry() {
   return { platform, runtime, sdkVersions };
 }
 
+// src/format.ts
+var SUPPORTED_FORMATS = ["png", "jpeg", "webp"];
+var isSupportedFormat = (value) => SUPPORTED_FORMATS.includes(value);
+var validateImageFormat = (value) => {
+  if (!value) {
+    return { ok: true, format: "png" };
+  }
+  if (isSupportedFormat(value)) {
+    return { ok: true, format: value };
+  }
+  return {
+    ok: false,
+    error: {
+      message: `Unsupported format "${value}". Valid formats are png, jpeg, or webp.`
+    }
+  };
+};
+
 // src/types.ts
 var timeoutError = {
   error: {
@@ -590,6 +587,15 @@ var timeoutError = {
 };
 
 // src/client.ts
+var invalidFormatResult = (value) => ({
+  error: {
+    // @ts-ignore – local validation error
+    code: "INVALID_FORMAT",
+    docs: "https://bannerify.co/docs",
+    message: `Unsupported format "${value ?? "undefined"}". Valid formats are png, jpeg, or webp.`,
+    requestId: "local"
+  }
+});
 function createClient(apiKey, opts) {
   return new Bannerify(apiKey, opts);
 }
@@ -608,32 +614,35 @@ var Bannerify = class {
         "X-Platform": telemetry?.platform,
         "X-Runtime": telemetry?.runtime
       },
-      timeout: opts?.timeout ?? 1e4
+      timeout: opts?.timeout ?? 6e4
     });
   }
   client;
   baseUrl;
   async createImage(templateId, options) {
     try {
+      const normalizedFormat = validateImageFormat(options?.format);
+      if (!normalizedFormat.ok) {
+        return invalidFormatResult(options?.format);
+      }
       const res = await this.client.post("templates/createImage", {
         json: {
           modifications: options?.modifications ?? [],
           // template: JSON.stringify(options?.template ?? {}),
           templateId,
           apiKey: this.apiKey,
-          format: options?.format
+          format: normalizedFormat.format,
+          thumbnail: options?.thumbnail ?? false
         }
       });
-      if (options?.format === "svg") {
-        return { result: await res.text() };
-      }
       return { result: await res.arrayBuffer() };
     } catch (e) {
       if (e instanceof HTTPError) {
-        return (await e.response.json())["error"];
+        const json = await e.response.json();
+        return { error: json.error };
       }
       if (e instanceof TimeoutError) {
-        return timeoutError;
+        return { error: timeoutError.error };
       }
       throw e;
     }
@@ -645,40 +654,47 @@ var Bannerify = class {
           modifications: options?.modifications ?? [],
           // template: JSON.stringify(options?.template ?? {}),
           templateId,
-          apiKey: this.apiKey,
-          format: options?.format
+          apiKey: this.apiKey
         }
       });
       return { result: await res.arrayBuffer() };
     } catch (e) {
       if (e instanceof HTTPError) {
-        return (await e.response.json())["error"];
+        const json = await e.response.json();
+        return { error: json.error };
       }
       if (e instanceof TimeoutError) {
-        return timeoutError;
+        return { error: timeoutError.error };
       }
       throw e;
     }
   }
   async createStoredImage(templateId, options) {
     try {
+      const normalizedFormat = validateImageFormat(options?.format);
+      if (!normalizedFormat.ok) {
+        return invalidFormatResult(options?.format);
+      }
       const res = await this.client.post("templates/createStoredImage", {
         json: {
           modifications: options?.modifications ?? [],
           // template: JSON.stringify(options?.template ?? {}),
           templateId,
           apiKey: this.apiKey,
-          format: options?.format
+          format: normalizedFormat.format,
+          thumbnail: options?.thumbnail ?? false,
+          s3Config: options?.s3Config
         }
       });
       const json = await res.json();
       return { result: json.url };
     } catch (e) {
       if (e instanceof HTTPError) {
-        return (await e.response.json())["error"];
+        const json = await e.response.json();
+        return { error: json.error };
       }
       if (e instanceof TimeoutError) {
-        return timeoutError;
+        return { error: timeoutError.error };
       }
       throw e;
     }
@@ -690,12 +706,33 @@ var Bannerify = class {
     const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
     return hashHex;
   };
+  // The signature is an HMAC keyed with the API key itself, so a signed URL can
+  // be shared without exposing anything that can sign a different one. The
+  // apiKeyHashed in the URL only tells the server which key to verify with.
+  #signText = async (text) => {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode(this.apiKey),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  };
   async generateImageSignedUrl(templateId, options) {
     const apiKeyHashed = await this.#hashText(this.apiKey);
     const searchParams = new URLSearchParams();
     searchParams.set("apiKeyHashed", apiKeyHashed);
-    if (options?.format === "svg") {
-      searchParams.set("format", "svg");
+    if (options?.format) {
+      const normalizedFormat = validateImageFormat(options.format);
+      if (!normalizedFormat.ok) {
+        throw new Error(normalizedFormat.error.message);
+      }
+      searchParams.set("format", normalizedFormat.format);
+    }
+    if (options?.quality !== void 0) {
+      searchParams.set("quality", String(options.quality));
     }
     if (options?.modifications) {
       searchParams.set("modifications", JSON.stringify(options?.modifications));
@@ -703,12 +740,12 @@ var Bannerify = class {
     if (options?.nocache) {
       searchParams.set("nocache", "true");
     }
+    if (options?.thumbnail) {
+      searchParams.set("thumbnail", "true");
+    }
     searchParams.set("templateId", templateId);
     searchParams.sort();
-    searchParams.set(
-      "sign",
-      await this.#hashText(searchParams.toString() + searchParams.get("apiKeyHashed"))
-    );
+    searchParams.set("sign", await this.#signText(searchParams.toString()));
     return `${this.baseUrl}/templates/signedurl?${searchParams.toString()}`;
   }
 };