@adgytec/adgytec-web-utils 0.0.1 → 0.0.2

package/dist/chunks/apiError

@@ -0,0 +1,24 @@
+import * as r from "zod";
+class t extends Error {
+}
+const a = r.object({
+  message: r.string().optional(),
+  fieldErrors: r.record(r.string(), r.union([r.string(), r.array(r.string())])).optional()
+}), n = (o) => {
+  const s = a.safeParse(o), e = s.success && !s.data.message && !s.data.fieldErrors;
+  return !s.success || e ? {
+    message: "Unexpected server error"
+  } : s.data;
+};
+class c extends t {
+  data;
+  response;
+  constructor(s, e) {
+    super(e.message ?? "API Error"), this.name = "API Error", this.data = e, this.response = s;
+  }
+}
+export {
+  c as A,
+  t as B,
+  n
+};

package/dist/chunks/decode

@@ -0,0 +1,39 @@
+import { A as r, n as f } from "./apiError";
+import "zod";
+async function i(e, s) {
+  const n = await e.text();
+  if (!n) {
+    if (e.ok) {
+      if (s)
+        throw new r(e, {
+          message: "Expected response body but received empty response"
+        });
+      return null;
+    }
+    throw new r(e, {
+      message: "Empty error response from server"
+    });
+  }
+  let t;
+  try {
+    t = JSON.parse(n);
+  } catch {
+    const p = e.ok ? "Malformed JSON response from server" : "Malformed error response from server";
+    throw new r(e, { message: p });
+  }
+  if (e.ok) {
+    if (!s)
+      return null;
+    const o = s.safeParse(t);
+    if (!o.success)
+      throw new r(e, {
+        message: `Invalid response shape from server: ${o.error.message}`
+      });
+    return o.data;
+  }
+  const a = f(t);
+  throw new r(e, a);
+}
+export {
+  i as d
+};

package/dist/chunks/parse

@@ -0,0 +1,88 @@
+import { A as o, B as n } from "./apiError";
+const d = 1e3, c = (e) => {
+  if (e instanceof TypeError && (e.message === "Failed to fetch" || e.message === "NetworkError when attempting to fetch resource." || e.message === "Load failed" || // Safari
+  e.message.includes("NetworkError") || e.message.includes("fetch")))
+    return {
+      errorCode: "network-error",
+      message: "Check your network connection or try again later."
+    };
+  if (e instanceof o) {
+    if (e.response.status >= 500)
+      return {
+        errorCode: "server-error",
+        message: e.data?.message ?? "Internal server error. Please try again later."
+      };
+    switch (e.response.status) {
+      case 422:
+        return {
+          errorCode: "form-field-error",
+          fieldErrors: e.data.fieldErrors ?? {}
+        };
+      case 400:
+        return {
+          errorCode: "user-action-error",
+          message: e.data?.message ?? "Something went wrong while processing your request."
+        };
+      case 401:
+        return {
+          errorCode: "authentication-error",
+          message: e.data?.message ?? "User login required."
+        };
+      case 403:
+        return {
+          errorCode: "authorization-error",
+          message: e.data?.message ?? "You don't have necessary permissions to perform the requested action."
+        };
+      case 404:
+        return {
+          errorCode: "not-found-error",
+          message: e.data?.message ?? "Requested action not found."
+        };
+      case 405:
+        return {
+          errorCode: "method-not-allowed-error",
+          message: e.data?.message ?? "Requested action method not allowed."
+        };
+      case 429:
+        const r = e.response.headers.get("retry-after");
+        let s = d;
+        if (r) {
+          const t = parseInt(r, 10);
+          if (!isNaN(t))
+            s = t * 1e3;
+          else {
+            const a = new Date(r);
+            isNaN(a.getTime()) || (s = Math.max(
+              0,
+              a.getTime() - Date.now()
+            ));
+          }
+        }
+        return {
+          errorCode: "too-many-requests-error",
+          retryAfter: s,
+          message: "Too many requests. Try again later."
+        };
+      case 413:
+        return {
+          errorCode: "content-too-large-error",
+          message: e.data?.message ?? "Request content too large."
+        };
+      default:
+        return {
+          errorCode: "unknown-error",
+          message: e.data?.message ?? "Unexpected error occurred."
+        };
+    }
+  }
+  return e instanceof n ? {
+    errorCode: "unknown-error",
+    message: e.message
+  } : {
+    errorCode: "unknown-error",
+    message: "Unknown error occurred. Please refresh this page or try again later."
+  };
+};
+export {
+  c as p
+};

package/dist/chunks/upload

@@ -0,0 +1,369 @@
+import r from "zod";
+import { v7 as c } from "uuid";
+import { B as n } from "./apiError";
+import { Queue as p } from "@datastructures-js/queue";
+import { p as l } from "./parse";
+import { d as h } from "./decode";
+import { HTTP_PUT as u, HTTP_HEADER_USER_LOCALE as m, HTTP_REQUEST_CREDENTIALS_INCLUDE as f, HTTP_POST as y, HTTP_HEADER_CONTENT_TYPE_APPLICATION_JSON as w, HTTP_HEADER_CONTENT_TYPE as g } from "../constants/index.js";
+const U = r.object({
+  presignPut: r.url(),
+  partNumber: r.int().positive().lte(1e4),
+  partSize: r.int().positive().gt(0)
+}), P = r.object({
+  mediaID: r.uuidv7(),
+  uploadType: r.literal("multipart"),
+  multipartPresignPart: r.array(U).nonempty(),
+  multipartSuccessCallback: r.url()
+}), C = r.object({
+  mediaID: r.uuidv7(),
+  uploadType: r.literal("singlepart"),
+  presignPut: r.url(),
+  singlepartSuccessCallback: r.url()
+}), B = r.discriminatedUnion("uploadType", [
+  P,
+  C
+]), T = (s) => ({
+  id: c(),
+  name: s.name,
+  size: s.size,
+  file: s
+}), $ = (s) => s.map(T), E = (s) => ({
+  id: s.id,
+  size: s.size,
+  name: s.name
+}), k = (s) => s.map(E), R = (s, t) => {
+  if (s.id !== t.mediaID)
+    throw new n("media item and response id mismatch");
+  return {
+    ...t,
+    file: s.file,
+    size: s.size
+  };
+}, q = (s, t) => {
+  if (s.length !== t.length)
+    throw new n(
+      `items mismatch: mediaInfos=${s.length}, apiResponses=${t.length}`
+    );
+  const e = new Map(
+    t.map((i) => [i.mediaID, i])
+  );
+  return s.map((i) => {
+    const a = e.get(i.id);
+    if (!a)
+      throw new n(
+        `Could not find a matching API response for media info with id: ${i.id}`
+      );
+    return R(i, a);
+  });
+};
+class S {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  #n;
+  #o;
+  #r;
+  constructor(t, e, i, a) {
+    this.#s = t, this.#t = e, this.#a = [], this.#i = /* @__PURE__ */ new Set(), this.#e = a, this.#n = i, this.#o = !1, this.#r = !1;
+  }
+  get failed() {
+    return this.#o;
+  }
+  fail() {
+    this.#o = !0;
+  }
+  get id() {
+    return this.#s;
+  }
+  get completeURL() {
+    return this.#n;
+  }
+  get blob() {
+    return this.#t;
+  }
+  add(t) {
+    this.contains(t.partNumber) || (this.#a.push(t), this.#i.add(t.partNumber));
+  }
+  contains(t) {
+    return this.#i.has(t);
+  }
+  get list() {
+    return this.#a.slice().sort((t, e) => t.partNumber - e.partNumber);
+  }
+  get canComplete() {
+    return !this.failed && this.#i.size === this.#e;
+  }
+  tryStartComplete() {
+    return this.#r || !this.canComplete ? !1 : (this.#r = !0, !0);
+  }
+  resetComplete() {
+    this.#r = !1;
+  }
+  get totalPartsCount() {
+    return this.#e;
+  }
+  get uploadedPartsCount() {
+    return this.#i.size;
+  }
+}
+class N {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  constructor(t, e, i, a) {
+    this.#s = t, this.#t = e, this.#i = a, this.#a = i, this.#e = !1;
+  }
+  get canComplete() {
+    return this.#e;
+  }
+  allowComplete() {
+    this.#e = !0;
+  }
+  get id() {
+    return this.#s;
+  }
+  get blob() {
+    return this.#t;
+  }
+  get completeURL() {
+    return this.#i;
+  }
+  get uploadURL() {
+    return this.#a;
+  }
+}
+const L = {
+  concurrentUploads: 4,
+  retryLimit: 3
+};
+class _ {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  #n;
+  constructor(t, e, i = L, a) {
+    this.#s = t, this.#t = e, this.#a = i.concurrentUploads, this.#i = i.retryLimit, this.#e = new p(), this.#n = a;
+  }
+  #o(t) {
+    return t < this.#i;
+  }
+  #r(t) {
+    this.#e.enqueue(t);
+  }
+  async init() {
+    this.#t.init(this.#s);
+    const t = /* @__PURE__ */ new Set();
+    for await (const e of this.#m()) {
+      const i = e().finally(() => t.delete(i));
+      t.add(i), t.size >= this.#a && await Promise.race(t);
+    }
+    await Promise.all(t), await this.#y(), this.#t.completed();
+  }
+  async #l(t, e) {
+    return await fetch(t, {
+      method: u,
+      body: e
+    });
+  }
+  async #d(t, e = 0) {
+    if (!t.canComplete)
+      try {
+        if (!(await this.#l(
+          t.uploadURL,
+          t.blob
+        )).ok)
+          throw new n(
+            `Failed to upload file blob for media item ${t.id}`
+          );
+        t.allowComplete(), await this.#h(t);
+      } catch (i) {
+        const a = l(i);
+        this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "singlepart-upload",
+          retryCount: e + 1,
+          singlepartObj: t
+        })) : this.#t.failed(t.id, a);
+      }
+  }
+  async #c(t, e, i = 0) {
+    if (!(t.failed || t.contains(e.partNumber)))
+      try {
+        const a = await this.#l(
+          e.uploadURL,
+          t.blob.slice(e.startByte, e.endByte)
+        );
+        if (!a.ok)
+          throw new n(
+            `Failed to upload part ${e.partNumber} for media item ${t.id}`
+          );
+        const o = a.headers.get("ETag");
+        if (!o)
+          throw new n("missing etag");
+        if (t.add({
+          partNumber: e.partNumber,
+          etag: o
+        }), this.#t.multipartPartUploaded(
+          t.id,
+          t.uploadedPartsCount,
+          t.totalPartsCount
+        ), !t.canComplete) return;
+        await this.#u(t);
+      } catch (a) {
+        const o = l(a);
+        this.#o(i) ? (this.#t.multipartPartUploadRetrying(
+          t.id,
+          e.partNumber
+        ), this.#r({
+          type: "multipart-part-upload",
+          retryCount: i + 1,
+          multipartObj: t,
+          partInfo: e
+        })) : (t.fail(), this.#t.failed(t.id, o));
+      }
+  }
+  async #p(t, e) {
+    let i, a;
+    e && (i = JSON.stringify({
+      partsInfo: e
+    }), a = {
+      [g]: w
+    }), this.#n && (a = a || {}, a[m] = this.#n);
+    const o = await fetch(t, {
+      method: y,
+      body: i,
+      headers: a,
+      credentials: f
+    });
+    await h(o);
+  }
+  async #h(t, e = 0) {
+    if (t.canComplete)
+      try {
+        await this.#p(t.completeURL), this.#t.itemUploaded(t.id);
+      } catch (i) {
+        const a = l(i);
+        this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "singlepart-complete",
+          retryCount: e + 1,
+          singlepartObj: t
+        })) : this.#t.failed(t.id, a);
+      }
+  }
+  async #u(t, e = 0) {
+    if (t.tryStartComplete())
+      try {
+        await this.#p(
+          t.completeURL,
+          t.list
+        ), this.#t.itemUploaded(t.id);
+      } catch (i) {
+        t.resetComplete();
+        const a = l(i);
+        this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "multipart-complete",
+          retryCount: e + 1,
+          multipartObj: t
+        })) : (t.fail(), this.#t.failed(t.id, a));
+      }
+  }
+  async *#m() {
+    for (const t of this.#s) {
+      if (t.uploadType === "singlepart") {
+        const o = new N(
+          t.mediaID,
+          t.file,
+          t.presignPut,
+          t.singlepartSuccessCallback
+        );
+        yield async () => {
+          await this.#d(o);
+        };
+        continue;
+      }
+      const e = new S(
+        t.mediaID,
+        t.file,
+        t.multipartSuccessCallback,
+        t.multipartPresignPart.length
+      );
+      let i = 0, a = 0;
+      for (const o of t.multipartPresignPart) {
+        a += o.partSize;
+        const d = {
+          partNumber: o.partNumber,
+          uploadURL: o.presignPut,
+          startByte: i,
+          endByte: a
+        };
+        yield async () => {
+          await this.#c(e, d);
+        }, i = a;
+      }
+    }
+  }
+  #f(t) {
+    switch (t.type) {
+      case "singlepart-upload":
+        return this.#d(
+          t.singlepartObj,
+          t.retryCount
+        );
+      case "singlepart-complete":
+        return this.#h(
+          t.singlepartObj,
+          t.retryCount
+        );
+      case "multipart-part-upload":
+        return this.#c(
+          t.multipartObj,
+          t.partInfo,
+          t.retryCount
+        );
+      case "multipart-complete":
+        return this.#u(
+          t.multipartObj,
+          t.retryCount
+        );
+      default:
+        const e = t;
+        throw new n(
+          `Unhandled retry task type: ${e.type}`
+        );
+    }
+  }
+  async #y() {
+    const t = /* @__PURE__ */ new Set();
+    for (; !this.#e.isEmpty(); ) {
+      for (; !this.#e.isEmpty(); ) {
+        const e = this.#e.dequeue();
+        let i = this.#f(e).finally(
+          () => t.delete(i)
+        );
+        t.add(i), t.size >= this.#a && await Promise.race(t);
+      }
+      await Promise.all(t);
+    }
+  }
+}
+const Q = async (s, t, e, i) => {
+  await D([s], t, e, i);
+}, D = async (s, t, e, i) => {
+  await new _(s, t, e, i).init();
+};
+export {
+  B as U,
+  $ as a,
+  R as b,
+  q as c,
+  k as d,
+  D as e,
+  T as n,
+  E as t,
+  Q as u
+};

package/dist/constants/http.d.ts

@@ -0,0 +1,5 @@
+export declare const HTTP_GET = "GET";
+export declare const HTTP_POST = "POST";
+export declare const HTTP_PUT = "PUT";
+export declare const HTTP_PATCH = "PATCH";
+export declare const HTTP_DELETE = "DELETE";

package/dist/constants/httpRequest.d.ts

@@ -0,0 +1,3 @@
+export declare const HTTP_REQUEST_CREDENTIALS_INCLUDE = "include";
+export declare const HTTP_REQUEST_CREDENTIALS_SAME_ORIGIN = "same-origin";
+export declare const HTTP_REQUEST_CREDENTIALS_NONE = "none";

package/dist/constants/httpRequestHeaders.d.ts

@@ -0,0 +1,6 @@
+export declare const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
+export declare const HTTP_HEADER_CONTENT_TYPE_APPLICATION_JSON = "application/json";
+export declare const HTTP_HEADER_AUTHORIZATION = "Authorization";
+export declare const HTTP_HEADER_AUTHORIZATION_BEARER_SCHEME = "Bearer";
+export declare const HTTP_HEADER_AUTHORIZATION_BASIC_SCHEME = "Basic";
+export declare const HTTP_HEADER_USER_LOCALE = "x-user-locale";

package/dist/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from './http';
+export * from './httpRequestHeaders';
+export * from './httpRequest';

package/dist/constants/index.js

@@ -0,0 +1,17 @@
+const T = "GET", E = "POST", _ = "PUT", H = "PATCH", A = "DELETE", P = "Content-Type", n = "application/json", o = "Authorization", t = "Bearer", R = "Basic", c = "x-user-locale", s = "include", N = "same-origin", I = "none";
+export {
+  A as HTTP_DELETE,
+  T as HTTP_GET,
+  o as HTTP_HEADER_AUTHORIZATION,
+  R as HTTP_HEADER_AUTHORIZATION_BASIC_SCHEME,
+  t as HTTP_HEADER_AUTHORIZATION_BEARER_SCHEME,
+  P as HTTP_HEADER_CONTENT_TYPE,
+  n as HTTP_HEADER_CONTENT_TYPE_APPLICATION_JSON,
+  c as HTTP_HEADER_USER_LOCALE,
+  H as HTTP_PATCH,
+  E as HTTP_POST,
+  _ as HTTP_PUT,
+  s as HTTP_REQUEST_CREDENTIALS_INCLUDE,
+  I as HTTP_REQUEST_CREDENTIALS_NONE,
+  N as HTTP_REQUEST_CREDENTIALS_SAME_ORIGIN
+};

package/dist/errors/index.js

@@ -0,0 +1,8 @@
+import { A as s, B as e, n as a } from "../chunks/apiError";
+import { p as E } from "../chunks/parse";
+export {
+  s as APIError,
+  e as BaseError,
+  a as newAPIErrorResponse,
+  E as parseError
+};

package/dist/index.d.ts

@@ -1,2 +1,4 @@
+export * from './constants';
 export * from './errors';
+export * from './media';
 export * from './response';