@adgytec/adgytec-web-utils 0.0.4 → 0.0.6

package/dist/chunks/create

@@ -0,0 +1,24 @@
+import { m as a } from "./server";
+import { A as d } from "./schema";
+function n(o, r) {
+  const e = {
+    code: a.mediaItemsLimitExceeded,
+    currentLength: o,
+    maxItemsSupported: r
+  };
+  throw new d(e.code, e);
+}
+function c(o, r, e) {
+  const i = {
+    code: a.mediaTooLarge,
+    mediaID: o,
+    currentSize: r,
+    maxSupportedSize: e
+  };
+  throw new d(i.code, i);
+}
+export {
+  c as a,
+  n
+};
+//# sourceMappingURL=create.map

package/dist/chunks/create.map

@@ -0,0 +1 @@
+{"version":3,"file":"create","sources":["../../src/errorSchema/create.ts"],"sourcesContent":["import type z from \"zod\";\nimport { mediaCodes } from \"../errorCodes\";\nimport { ApplicationError } from \"../errors\";\nimport type {\n    mediaItemsLimitExceededSchema,\n    mediaTooLargeSchema,\n} from \"./media\";\n\ntype MediaItemsLimitExceeded = z.infer<typeof mediaItemsLimitExceededSchema>;\n\nexport function newMediaItemsLimitExceedError(\n    currentLength: number,\n    maxItemsSupported: number\n): never {\n    const errObj: MediaItemsLimitExceeded = {\n        code: mediaCodes.mediaItemsLimitExceeded,\n        currentLength,\n        maxItemsSupported,\n    };\n    throw new ApplicationError(errObj.code, errObj);\n}\n\ntype MediaTooLarge = z.infer<typeof mediaTooLargeSchema>;\n\nexport function newMediaTooLargeError(\n    fileName: string,\n    currentSize: number,\n    maxSupportedSize: number\n): never {\n    // use file as mediaID to handle client side error\n    const errObj: MediaTooLarge = {\n        code: mediaCodes.mediaTooLarge,\n        mediaID: fileName,\n        currentSize,\n        maxSupportedSize,\n    };\n    throw new ApplicationError(errObj.code, errObj);\n}\n"],"names":["newMediaItemsLimitExceedError","currentLength","maxItemsSupported","errObj","mediaCodes","ApplicationError","newMediaTooLargeError","fileName","currentSize","maxSupportedSize"],"mappings":";;AAUO,SAASA,EACZC,GACAC,GACK;AACL,QAAMC,IAAkC;AAAA,IACpC,MAAMC,EAAW;AAAA,IACjB,eAAAH;AAAA,IACA,mBAAAC;AAAA,EAAA;AAEJ,QAAM,IAAIG,EAAiBF,EAAO,MAAMA,CAAM;AAClD;AAIO,SAASG,EACZC,GACAC,GACAC,GACK;AAEL,QAAMN,IAAwB;AAAA,IAC1B,MAAMC,EAAW;AAAA,IACjB,SAASG;AAAA,IACT,aAAAC;AAAA,IACA,kBAAAC;AAAA,EAAA;AAEJ,QAAM,IAAIJ,EAAiBF,EAAO,MAAMA,CAAM;AAClD;"}

package/dist/chunks/decode

@@ -1,50 +1,51 @@
+import { s as n } from "./server";
+import { A as o } from "./schema";
 import a from "zod";
-import { A as s } from "./applicationError";
-import { serverCodes as t } from "../errorCodes/index.js";
-function c(e, o) {
+const i = a.object({
+  code: a.string()
+}).loose();
+function c(e, s) {
+  const r = i.safeParse(s);
+  throw r.success ? new o(r.data.code, r.data) : e >= 500 ? new o(n.internalServerError) : new o(n.unknownServerError, {
+    payload: s
+  });
+}
+function p(e, s) {
   if (!e)
-    throw new s(t.invalidResponseShape, {
+    throw new o(n.invalidResponseShape, {
       message: "Expected response body but received empty response",
       payload: e
     });
-  const r = o.safeParse(e);
+  const r = s.safeParse(e);
   if (r.success) return r.data;
-  throw new s(t.invalidResponseShape, {
+  throw new o(n.invalidResponseShape, {
     message: r.error.message,
     payload: e
   });
 }
-const i = a.object({
-  code: a.string()
-}).loose();
-function p(e, o) {
-  const r = i.safeParse(o);
-  throw r.success ? new s(r.data.code, r.data) : e >= 500 ? new s(t.internalServerError) : new s(t.unknownServerError, {
-    payload: o
-  });
-}
-async function u(e, o) {
-  if (!o && e.ok)
+async function d(e, s) {
+  if (!s && e.ok)
     return null;
   let r;
   try {
     r = await e.text();
   } catch {
-    throw new s(t.malformedResponseBody, {
+    throw new o(n.malformedResponseBody, {
       response: e
     });
   }
-  let n;
+  let t;
   if (r.length > 0)
     try {
-      n = JSON.parse(r);
+      t = JSON.parse(r);
     } catch {
-      throw new s(t.malformedJsonFromServer, {
+      throw new o(n.malformedJsonFromServer, {
         response: e
       });
     }
-  return e.ok ? c(n, o) : p(e.status, n);
+  return e.ok ? s ? p(t, s) : null : c(e.status, t);
 }
 export {
-  u as d
+  d
 };
+//# sourceMappingURL=decode.map

package/dist/chunks/decode.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode","sources":["../../src/response/errorResponse.ts","../../src/response/successReponse.ts","../../src/response/decode.ts"],"sourcesContent":["import z from \"zod\";\nimport { serverCodes } from \"../errorCodes\";\nimport { ApplicationError } from \"../errors\";\n\nconst serverErrorSchema = z\n    .object({\n        code: z.string(),\n    })\n    .loose();\n\nexport function parseErrorResponse(status: number, payload: unknown): never {\n    const result = serverErrorSchema.safeParse(payload);\n    if (result.success) {\n        throw new ApplicationError(result.data.code, result.data);\n    }\n\n    if (status >= 500) {\n        throw new ApplicationError(serverCodes.internalServerError);\n    }\n\n    throw new ApplicationError(serverCodes.unknownServerError, {\n        payload,\n    });\n}\n","import type z from \"zod\";\nimport { serverCodes } from \"../errorCodes\";\nimport { ApplicationError } from \"../errors\";\n\nexport function parseSuccessReponse<T>(\n    payload: unknown,\n    schema: z.ZodSchema<T>\n): T {\n    if (!payload) {\n        throw new ApplicationError(serverCodes.invalidResponseShape, {\n            message: \"Expected response body but received empty response\",\n            payload: payload,\n        });\n    }\n\n    const parsed = schema.safeParse(payload);\n    if (parsed.success) return parsed.data;\n\n    throw new ApplicationError(serverCodes.invalidResponseShape, {\n        message: parsed.error.message,\n        payload: payload,\n    });\n}\n","import type z from \"zod\";\nimport { serverCodes } from \"../errorCodes\";\nimport { ApplicationError } from \"../errors\";\nimport { parseErrorResponse } from \"./errorResponse\";\nimport { parseSuccessReponse } from \"./successReponse\";\n\n// overloaded functions\nexport function decodeAPIResponse<T>(\n    res: Response,\n    schema: z.ZodSchema<T>\n): Promise<T>;\n\nexport function decodeAPIResponse(res: Response): Promise<null>;\n\nexport async function decodeAPIResponse<T>(\n    res: Response,\n    schema?: z.ZodSchema<T>\n): Promise<T | null> {\n    // no need to handle response body\n    // caller expects no response\n    if (!schema && res.ok) {\n        return null;\n    }\n\n    let raw: string;\n    try {\n        raw = await res.text();\n    } catch {\n        throw new ApplicationError(serverCodes.malformedResponseBody, {\n            response: res,\n        });\n    }\n\n    let payload: unknown;\n    if (raw.length > 0) {\n        try {\n            payload = JSON.parse(raw);\n        } catch {\n            throw new ApplicationError(serverCodes.malformedJsonFromServer, {\n                response: res,\n            });\n        }\n    }\n\n    if (res.ok) {\n        if (schema) return parseSuccessReponse(payload, schema);\n        return null;\n    }\n\n    return parseErrorResponse(res.status, payload);\n}\n"],"names":["serverErrorSchema","z","parseErrorResponse","status","payload","result","ApplicationError","serverCodes","parseSuccessReponse","schema","parsed","decodeAPIResponse","res","raw"],"mappings":";;;AAIA,MAAMA,IAAoBC,EACrB,OAAO;AAAA,EACJ,MAAMA,EAAE,OAAA;AACZ,CAAC,EACA,MAAA;AAEE,SAASC,EAAmBC,GAAgBC,GAAyB;AACxE,QAAMC,IAASL,EAAkB,UAAUI,CAAO;AAClD,QAAIC,EAAO,UACD,IAAIC,EAAiBD,EAAO,KAAK,MAAMA,EAAO,IAAI,IAGxDF,KAAU,MACJ,IAAIG,EAAiBC,EAAY,mBAAmB,IAGxD,IAAID,EAAiBC,EAAY,oBAAoB;AAAA,IACvD,SAAAH;AAAA,EAAA,CACH;AACL;ACnBO,SAASI,EACZJ,GACAK,GACC;AACD,MAAI,CAACL;AACD,UAAM,IAAIE,EAAiBC,EAAY,sBAAsB;AAAA,MACzD,SAAS;AAAA,MACT,SAAAH;AAAA,IAAA,CACH;AAGL,QAAMM,IAASD,EAAO,UAAUL,CAAO;AACvC,MAAIM,EAAO,QAAS,QAAOA,EAAO;AAElC,QAAM,IAAIJ,EAAiBC,EAAY,sBAAsB;AAAA,IACzD,SAASG,EAAO,MAAM;AAAA,IACtB,SAAAN;AAAA,EAAA,CACH;AACL;ACRA,eAAsBO,EAClBC,GACAH,GACiB;AAGjB,MAAI,CAACA,KAAUG,EAAI;AACf,WAAO;AAGX,MAAIC;AACJ,MAAI;AACA,IAAAA,IAAM,MAAMD,EAAI,KAAA;AAAA,EACpB,QAAQ;AACJ,UAAM,IAAIN,EAAiBC,EAAY,uBAAuB;AAAA,MAC1D,UAAUK;AAAA,IAAA,CACb;AAAA,EACL;AAEA,MAAIR;AACJ,MAAIS,EAAI,SAAS;AACb,QAAI;AACA,MAAAT,IAAU,KAAK,MAAMS,CAAG;AAAA,IAC5B,QAAQ;AACJ,YAAM,IAAIP,EAAiBC,EAAY,yBAAyB;AAAA,QAC5D,UAAUK;AAAA,MAAA,CACb;AAAA,IACL;AAGJ,SAAIA,EAAI,KACAH,IAAeD,EAAoBJ,GAASK,CAAM,IAC/C,OAGJP,EAAmBU,EAAI,QAAQR,CAAO;AACjD;"}

package/dist/chunks/formParse

@@ -9,3 +9,4 @@ function t(s, n = "") {
 export {
   t as f
 };
+//# sourceMappingURL=formParse.map

package/dist/chunks/formParse.map

@@ -0,0 +1 @@
+{"version":3,"file":"formParse","sources":["../../src/errorSchema/formParse.ts"],"sourcesContent":["import type { FieldNode } from \"./form\";\nimport type { FormFieldError } from \"./formField\";\n\nexport type FlattenedErrors = Record<string, FormFieldError[]>;\n\nexport function flattenFieldNodes(\n    nodes: FieldNode[],\n    parentKey = \"\"\n): FlattenedErrors {\n    const result: FlattenedErrors = {};\n\n    for (const node of nodes) {\n        const currentKey = parentKey ? `${parentKey}.${node.key}` : node.key;\n\n        if (\"errors\" in node) {\n            result[currentKey] = node.errors;\n        } else {\n            Object.assign(result, flattenFieldNodes(node.children, currentKey));\n        }\n    }\n\n    return result;\n}\n"],"names":["flattenFieldNodes","nodes","parentKey","result","node","currentKey"],"mappings":"AAKO,SAASA,EACZC,GACAC,IAAY,IACG;AACf,QAAMC,IAA0B,CAAA;AAEhC,aAAWC,KAAQH,GAAO;AACtB,UAAMI,IAAaH,IAAY,GAAGA,CAAS,IAAIE,EAAK,GAAG,KAAKA,EAAK;AAEjE,IAAI,YAAYA,IACZD,EAAOE,CAAU,IAAID,EAAK,SAE1B,OAAO,OAAOD,GAAQH,EAAkBI,EAAK,UAAUC,CAAU,CAAC;AAAA,EAE1E;AAEA,SAAOF;AACX;"}

package/dist/chunks/parse

@@ -1,25 +1,43 @@
-import e from "is-network-error";
-import { commonCodes as t } from "../errorCodes/index.js";
-import { A as n } from "./applicationError";
-import i from "zod";
-function p(r) {
-  if (e(r))
+import { defaultOverrides as c } from "../errorCodes/index.js";
+import f from "is-network-error";
+import s from "zod";
+import { c as i } from "./server";
+import { A as a } from "./schema";
+const d = (r) => {
+  const o = /* @__PURE__ */ new Map();
+  for (const { code: t, items: n } of r)
+    for (const e of n)
+      o.has(e) || o.set(e, t);
+  return o;
+}, m = d(c), M = (r, o) => {
+  if (o) {
+    for (const { items: n, code: e } of o)
+      if (n.includes(r.code))
+        return { code: e };
+  }
+  const t = m.get(r.code);
+  return t ? { code: t } : r;
+};
+function z(r) {
+  if (f(r))
     return {
-      code: t.networkError,
+      code: i.networkError,
       debugMessage: r.toString()
     };
-  if (r instanceof n) {
+  if (r instanceof a) {
     const o = r.parse();
-    return o instanceof i.ZodError ? {
-      code: t.zodError,
+    return o instanceof s.ZodError ? {
+      code: i.zodError,
       error: o
     } : o;
   }
   return {
-    code: t.unexpectedError,
+    code: i.unexpectedError,
     debugMessage: r instanceof Error ? r.toString() : String(r)
   };
 }
 export {
-  p
+  M as n,
+  z as p
 };
+//# sourceMappingURL=parse.map

package/dist/chunks/parse.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse","sources":["../../src/errors/normalization.ts","../../src/errors/parse.ts"],"sourcesContent":["import { defaultOverrides } from \"../errorCodes\";\nimport type { ParseErrorResponse } from \"./parse\";\n\n// ErrorNormalization maps multiple internal/actual error codes\n// to a single standardized error code shown to the end user.\n//\n// code  → the normalized (user-facing) error code\n// items → list of original/internal error codes that should be mapped to `code`\nexport type ErrorNormalization = {\n    code: string;\n    items: readonly string[];\n};\n\nconst buildOverrideMap = (\n    overrides: readonly ErrorNormalization[]\n): ReadonlyMap<string, string> => {\n    const map = new Map<string, string>();\n    for (const { code, items } of overrides) {\n        for (const item of items) {\n            // first match should win\n            if (!map.has(item)) map.set(item, code);\n        }\n    }\n    return map;\n};\n\nconst defaultOverridesMap = buildOverrideMap(defaultOverrides);\n\n// Normalizes an error object to ensure a consistent `code` for downstream usage (e.g. translations/UI).\n//\n// - Accepts both strongly-typed and flexible error objects (must contain `code`)\n// - Applies custom and default overrides to map multiple error codes to a single normalized code\n// - May intentionally strip additional fields when an override is applied\n// - Otherwise returns the original error object as-is\n//\n// Note: This function is intended for presentation layers, not for logic that depends on strict typing.\nexport const normalizeError = (\n    parsedResponse:\n        | ParseErrorResponse\n        | {\n              code: string;\n              [key: string]: unknown;\n          },\n    customOverrides?: readonly ErrorNormalization[]\n) => {\n    // no need to create map, this will be small set of overrides for custom actions only\n    if (customOverrides) {\n        for (const { items, code } of customOverrides) {\n            if (items.includes(parsedResponse.code)) {\n                return { code };\n            }\n        }\n    }\n\n    const normalizedCode = defaultOverridesMap.get(parsedResponse.code);\n    if (normalizedCode) {\n        return { code: normalizedCode };\n    }\n\n    return parsedResponse;\n};\n","import isNetworkError from \"is-network-error\";\nimport z from \"zod\";\nimport { commonCodes } from \"../errorCodes\";\nimport type { ErrorDetails } from \"../errorSchema\";\nimport { ApplicationError } from \"./applicationError\";\n\nexport type ParseErrorResponse =\n    | {\n          code: typeof commonCodes.networkError;\n          debugMessage: string;\n      }\n    | {\n          code: typeof commonCodes.unexpectedError;\n          debugMessage: string;\n      }\n    | {\n          code: typeof commonCodes.zodError;\n          error: z.ZodError;\n      }\n    | ErrorDetails;\n\nexport function parseError(err: unknown): ParseErrorResponse {\n    if (isNetworkError(err)) {\n        return {\n            code: commonCodes.networkError,\n            debugMessage: err.toString(),\n        };\n    }\n\n    if (err instanceof ApplicationError) {\n        const errVal = err.parse();\n        if (errVal instanceof z.ZodError) {\n            return {\n                code: commonCodes.zodError,\n                error: errVal,\n            };\n        }\n        return errVal;\n    }\n\n    return {\n        code: commonCodes.unexpectedError,\n        debugMessage: err instanceof Error ? err.toString() : String(err),\n    };\n}\n"],"names":["buildOverrideMap","overrides","map","code","items","item","defaultOverridesMap","defaultOverrides","normalizeError","parsedResponse","customOverrides","normalizedCode","parseError","err","isNetworkError","commonCodes","ApplicationError","errVal","z"],"mappings":";;;;;AAaA,MAAMA,IAAmB,CACrBC,MAC8B;AAC9B,QAAMC,wBAAU,IAAA;AAChB,aAAW,EAAE,MAAAC,GAAM,OAAAC,EAAA,KAAWH;AAC1B,eAAWI,KAAQD;AAEf,MAAKF,EAAI,IAAIG,CAAI,KAAGH,EAAI,IAAIG,GAAMF,CAAI;AAG9C,SAAOD;AACX,GAEMI,IAAsBN,EAAiBO,CAAgB,GAUhDC,IAAiB,CAC1BC,GAMAC,MACC;AAED,MAAIA;AACA,eAAW,EAAE,OAAAN,GAAO,MAAAD,EAAA,KAAUO;AAC1B,UAAIN,EAAM,SAASK,EAAe,IAAI;AAClC,eAAO,EAAE,MAAAN,EAAA;AAAA;AAKrB,QAAMQ,IAAiBL,EAAoB,IAAIG,EAAe,IAAI;AAClE,SAAIE,IACO,EAAE,MAAMA,EAAA,IAGZF;AACX;ACvCO,SAASG,EAAWC,GAAkC;AACzD,MAAIC,EAAeD,CAAG;AAClB,WAAO;AAAA,MACH,MAAME,EAAY;AAAA,MAClB,cAAcF,EAAI,SAAA;AAAA,IAAS;AAInC,MAAIA,aAAeG,GAAkB;AACjC,UAAMC,IAASJ,EAAI,MAAA;AACnB,WAAII,aAAkBC,EAAE,WACb;AAAA,MACH,MAAMH,EAAY;AAAA,MAClB,OAAOE;AAAA,IAAA,IAGRA;AAAA,EACX;AAEA,SAAO;AAAA,IACH,MAAMF,EAAY;AAAA,IAClB,cAAcF,aAAe,QAAQA,EAAI,SAAA,IAAa,OAAOA,CAAG;AAAA,EAAA;AAExE;"}