@scalar/api-client 2.2.22 → 2.2.23

package/dist/store/requests.js

@@ -1,107 +1,124 @@
-import { requestSchema as x, createExampleFromRequest as y } from "@scalar/oas-utils/entities/spec";
-import { LS_KEYS as F, schemaModel as T, iterateTitle as A } from "@scalar/oas-utils/helpers";
-import { mutationFactory as D } from "@scalar/object-utils/mutator-record";
-import { reactive as E } from "vue";
-function j(m) {
-  const s = E({}), h = D(
-    s,
-    E({}),
-    m && F.REQUEST
+import { requestSchema as y, createExampleFromRequest as F } from "@scalar/oas-utils/entities/spec";
+import { LS_KEYS as T, schemaModel as A, iterateTitle as D } from "@scalar/oas-utils/helpers";
+import { mutationFactory as I } from "@scalar/object-utils/mutator-record";
+import { reactive as S } from "vue";
+function C(q) {
+  const f = S({}), p = I(
+    f,
+    S({}),
+    q && T.REQUEST
   );
   return {
-    requests: s,
-    requestMutators: h
+    requests: f,
+    requestMutators: p
   };
 }
-function v({
-  requestExamples: m,
-  requestExampleMutators: s,
-  requestMutators: h,
-  collectionMutators: f,
-  collections: r,
-  tags: u,
-  tagMutators: q
-}, R) {
+function L({
+  requestExamples: q,
+  requestExampleMutators: f,
+  requestMutators: p,
+  collectionMutators: m,
+  collections: n,
+  tags: c,
+  tagMutators: R
+}, E) {
   return {
-    addRequest: (t, a) => {
+    addRequest: (r, t) => {
       var l;
-      const e = T(t, x, !1);
-      if (!e) return console.error("INVALID REQUEST DATA", t);
-      const o = r[a], i = y(
+      const e = A(r, y, !1);
+      if (!e) return console.error("INVALID REQUEST DATA", r);
+      const s = n[t], u = F(
         e,
-        A(
+        D(
           (e.summary ?? "Example") + " #1",
-          (c) => e.examples.some((p) => c === m[p].name)
+          (h) => e.examples.some((a) => {
+            var o;
+            return h === ((o = q[a]) == null ? void 0 : o.name);
+          })
         )
       );
-      return e.examples.push(i.uid), h.add(e), s.add(i), f.edit(a, "requests", [
-        ...o.requests,
+      return e.examples.push(u.uid), p.add(e), f.add(u), s && m.edit(t, "requests", [
+        ...s.requests,
         e.uid
-      ]), (l = e.tags) != null && l.length ? e.tags.forEach((c) => {
-        const p = o.tags.find((S) => u[S].name === c);
-        p ? q.edit(p, "children", [
-          ...u[p].children,
+      ]), (l = e.tags) != null && l.length ? e.tags.forEach((h) => {
+        const a = s == null ? void 0 : s.tags.find(
+          (o) => {
+            var x;
+            return ((x = c[o]) == null ? void 0 : x.name) === h;
+          }
+        );
+        a && c[a] ? R.edit(a, "children", [
+          ...c[a].children,
           e.uid
-        ]) : R({ name: c, children: [e.uid] }, a);
-      }) : f.edit(a, "children", [
-        ...o.children,
+        ]) : E({ name: h, children: [e.uid] }, t);
+      }) : s && m.edit(t, "children", [
+        ...s.children,
         e.uid
       ]), e;
     },
-    deleteRequest: (t, a) => {
-      var o;
-      const e = r[a];
-      t.examples.forEach((i) => s.delete(i)), f.edit(
-        a,
+    deleteRequest: (r, t) => {
+      var s;
+      const e = n[t];
+      r.examples.forEach((u) => f.delete(u)), e && (m.edit(
+        t,
         "requests",
-        e.requests.filter((i) => i !== t.uid)
-      ), f.edit(
-        a,
+        e.requests.filter((u) => u !== r.uid)
+      ), m.edit(
+        t,
         "children",
-        e.children.filter((i) => i !== t.uid)
-      ), (o = t.tags) == null || o.forEach((i) => {
-        const l = e.tags.find((c) => u[c].name === i);
-        l && q.edit(
+        e.children.filter((u) => u !== r.uid)
+      ), (s = r.tags) == null || s.forEach((u) => {
+        var h;
+        const l = e.tags.find(
+          (a) => {
+            var o;
+            return ((o = c[a]) == null ? void 0 : o.name) === u;
+          }
+        );
+        l && R.edit(
           l,
           "children",
-          u[l].children.filter((c) => c !== t.uid)
+          ((h = c[l]) == null ? void 0 : h.children.filter((a) => a !== r.uid)) || []
         );
-      }), h.delete(t.uid);
+      })), p.delete(r.uid);
     },
-    findRequestParents: I({ collections: r, tags: u })
+    findRequestParents: O({ collections: n, tags: c })
   };
 }
-function I({
-  collections: m,
-  tags: s
+function O({
+  collections: q,
+  tags: f
 }) {
-  function h(f) {
-    const r = Object.values(m).find(
-      (n) => {
-        var d;
-        return (d = n.requests) == null ? void 0 : d.includes(f.uid);
+  function p(m) {
+    const n = Object.values(q).find(
+      (d) => {
+        var i;
+        return (i = d.requests) == null ? void 0 : i.includes(m.uid);
       }
     );
-    if (!r) return [];
-    const u = Object.keys(s).reduce(
-      (n, d) => (n[d] = [], n),
-      { [r == null ? void 0 : r.uid]: [] }
+    if (!n) return [];
+    const c = Object.keys(f).reduce(
+      (d, i) => (d[i] = [], d),
+      { [n == null ? void 0 : n.uid]: [] }
     );
-    function q(n, d) {
-      d.forEach((t) => u[t].push(...n.children)), n.children.forEach((t) => {
-        s[t] && q(s[t], [...d, t]);
+    function R(d, i) {
+      i.forEach((r) => {
+        var t;
+        return (t = c[r]) == null ? void 0 : t.push(...d.children);
+      }), d.children.forEach((r) => {
+        f[r] && R(f[r], [...i, r]);
       });
     }
-    q(r, [r.uid]);
-    const R = /* @__PURE__ */ new Set();
-    return Object.entries(u).forEach(([n, d]) => {
-      d.includes(f.uid) && R.add(n);
-    }), [...R];
+    R(n, [n.uid]);
+    const E = /* @__PURE__ */ new Set();
+    return Object.entries(c).forEach(([d, i]) => {
+      i.includes(m.uid) && E.add(d);
+    }), [...E];
   }
-  return h;
+  return p;
 }
-function C() {
-  return { request: x.parse({
+function Q() {
+  return { request: y.parse({
     method: "get",
     parameters: [],
     path: "",
@@ -110,8 +127,8 @@ function C() {
   }) };
 }
 export {
-  C as createInitialRequest,
-  j as createStoreRequests,
-  v as extendedRequestDataFactory,
-  I as findRequestParentsFactory
+  Q as createInitialRequest,
+  C as createStoreRequests,
+  L as extendedRequestDataFactory,
+  O as findRequestParentsFactory
 };

package/dist/store/security-schemes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"security-schemes.d.ts","sourceRoot":"","sources":["../../src/store/security-schemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,iCAAiC,CAAA;AAKxC,mDAAmD;AACnD,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmFq/pD,CAAC;;;;;;;;;;;;oBAA4X,CAAC;;;;;;;;;;6BAA4V,CAAC;;;;;;;;;;6BAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;EAvErmsD;AAED,sDAAsD;AACtD,wBAAgB,2BAA2B,CAAC,EAC1C,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;iCAGF,qBAAqB,iBAEf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAyD+hqD,CAAC;;;;;;;;;;;;oBAA4X,CAAC;;;;;;;;;;6BAA4V,CAAC;;;;;;;;;;6BAAkV,CAAC;;;;;;;;;;;;;;;;sCAxC3jsD,MAAM;EAuChD"}
+{"version":3,"file":"security-schemes.d.ts","sourceRoot":"","sources":["../../src/store/security-schemes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,iCAAiC,CAAA;AAKxC,mDAAmD;AACnD,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmFs9pD,CAAC;;;;;;;;;;;;oBAA4X,CAAC;;;;;;;;;;6BAA4V,CAAC;;;;;;;;;;6BAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;wBAA9iC,CAAC;;;;;;;;;;;;wBAA4X,CAAC;;;;;;;;;;iCAA4V,CAAC;;;;;;;;;;iCAAkV,CAAC;;;;;;;;;;;;;;;;;;;;EAvEtksD;AAED,sDAAsD;AACtD,wBAAgB,2BAA2B,CAAC,EAC1C,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;iCAGF,qBAAqB,iBAEf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAyDggqD,CAAC;;;;;;;;;;;;oBAA4X,CAAC;;;;;;;;;;6BAA4V,CAAC;;;;;;;;;;6BAAkV,CAAC;;;;;;;;;;;;;;;;sCAxC5hsD,MAAM;EAuChD"}

package/dist/store/security-schemes.js

@@ -1,58 +1,58 @@
-import { securitySchemeSchema as a } from "@scalar/oas-utils/entities/spec";
+import { securitySchemeSchema as h } from "@scalar/oas-utils/entities/spec";
 import { LS_KEYS as n } from "@scalar/oas-utils/helpers";
-import { mutationFactory as h } from "@scalar/object-utils/mutator-record";
-import { reactive as f } from "vue";
-function O(u) {
-  const i = f({}), S = h(
-    i,
-    f({}),
-    u && n.SECURITY_SCHEME
+import { mutationFactory as o } from "@scalar/object-utils/mutator-record";
+import { reactive as a } from "vue";
+function v(S) {
+  const r = a({}), i = o(
+    r,
+    a({}),
+    S && n.SECURITY_SCHEME
   );
   return {
-    securitySchemes: i,
-    securitySchemeMutators: S
+    securitySchemes: r,
+    securitySchemeMutators: i
   };
 }
-function v({
-  securitySchemeMutators: u,
-  collectionMutators: i,
-  collections: S,
+function k({
+  securitySchemeMutators: S,
+  collectionMutators: r,
+  collections: i,
   requests: s,
   requestMutators: y
 }) {
   return {
     addSecurityScheme: (t, e) => {
-      const c = a.parse(t);
-      return u.add(c), e && i.edit(e, "securitySchemes", [
-        ...S[e].securitySchemes,
+      const c = h.parse(t);
+      return S.add(c), e && i[e] && r.edit(e, "securitySchemes", [
+        ...i[e].securitySchemes,
         c.uid
       ]), c;
     },
     deleteSecurityScheme: (t) => {
-      Object.values(S).forEach((e) => {
-        e.securitySchemes.includes(t) && i.edit(
+      Object.values(i).forEach((e) => {
+        e.securitySchemes.includes(t) && r.edit(
           e.uid,
           "securitySchemes",
           e.securitySchemes.filter((c) => c !== t)
         );
       }), Object.values(s).forEach((e) => {
-        var c, d, m;
-        (c = e.security) != null && c.some((r) => Object.keys(r).includes(t)) && y.edit(
+        var c, d, m, f;
+        (c = e.security) != null && c.some((u) => Object.keys(u).includes(t)) && y.edit(
           e.uid,
           "security",
-          (d = s[e.uid].security) == null ? void 0 : d.filter(
-            (r) => !Object.keys(r).includes(t)
+          (m = (d = s[e.uid]) == null ? void 0 : d.security) == null ? void 0 : m.filter(
+            (u) => !Object.keys(u).includes(t)
           )
         ), e.selectedSecuritySchemeUids.includes(t) && y.edit(
           e.uid,
           "selectedSecuritySchemeUids",
-          (m = e.selectedSecuritySchemeUids) == null ? void 0 : m.filter((r) => r !== t)
+          (f = e.selectedSecuritySchemeUids) == null ? void 0 : f.filter((u) => u !== t)
         );
-      }), u.delete(t);
+      }), S.delete(t);
     }
   };
 }
 export {
-  O as createStoreSecuritySchemes,
-  v as extendedSecurityDataFactory
+  v as createStoreSecuritySchemes,
+  k as extendedSecurityDataFactory
 };

package/dist/store/servers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../src/store/servers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,iCAAiC,CAAA;AAKxC,yCAAyC;AACzC,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,OAAO;;;;;;gBAqEutC,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;EAxDlxC;AAED,6CAA6C;AAC7C,wBAAgB,yBAAyB,CAAC,EACxC,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;yBAKe,aAAa,aAAa,MAAM;;;;;gBA0CotC,CAAC;;;8BAjBhvC,MAAM,iBAAiB,MAAM;EAgB/D"}
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../src/store/servers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,iCAAiC,CAAA;AAKxC,yCAAyC;AACzC,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,OAAO;;;;;;gBAuE0qC,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;EA1DruC;AAED,6CAA6C;AAC7C,wBAAgB,yBAAyB,CAAC,EACxC,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;yBAKe,aAAa,aAAa,MAAM;;;;;gBA4CuqC,CAAC;;;8BAnBnsC,MAAM,iBAAiB,MAAM;EAkB/D"}

package/dist/store/servers.js

@@ -1,46 +1,46 @@
-import { serverSchema as f } from "@scalar/oas-utils/entities/spec";
-import { LS_KEYS as a } from "@scalar/oas-utils/helpers";
-import { mutationFactory as u } from "@scalar/object-utils/mutator-record";
+import { serverSchema as o } from "@scalar/oas-utils/entities/spec";
+import { LS_KEYS as u } from "@scalar/oas-utils/helpers";
+import { mutationFactory as a } from "@scalar/object-utils/mutator-record";
 import { reactive as m } from "vue";
-function F(s) {
-  const r = m({}), v = u(
+function R(s) {
+  const r = m({}), v = a(
     r,
     m({}),
-    s && a.SERVER
+    s && u.SERVER
   );
   return {
     servers: r,
     serverMutators: v
   };
 }
-function R({
+function h({
   serverMutators: s,
   collections: r,
   collectionMutators: v,
-  requests: S,
+  requests: f,
   requestMutators: d
 }) {
   return {
-    addServer: (o, e) => {
-      const t = f.parse(o);
+    addServer: (S, e) => {
+      const t = o.parse(S);
       return r[e] ? v.edit(e, "servers", [
         ...r[e].servers,
         t.uid
-      ]) : S[e] && d.edit(e, "servers", [
-        ...S[e].servers,
+      ]) : f[e] && d.edit(e, "servers", [
+        ...f[e].servers,
         t.uid
       ]), s.add(t), t;
     },
-    deleteServer: (o, e) => {
-      v.edit(
+    deleteServer: (S, e) => {
+      r[e] && (v.edit(
         e,
         "servers",
-        r[e].servers.filter((t) => t !== o)
-      ), s.delete(o);
+        r[e].servers.filter((t) => t !== S)
+      ), s.delete(S));
     }
   };
 }
 export {
-  F as createStoreServers,
-  R as extendedServerDataFactory
+  R as createStoreServers,
+  h as extendedServerDataFactory
 };

package/dist/store/tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/store/tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EACL,KAAK,GAAG,EACR,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAA;AAKxC,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,eAAe,EAAE,OAAO;;;;;;;;;uBA0Fi9N,CAAC;;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;EA7EzgO;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,EACf,WAAW,GACZ,EAAE,YAAY;sBAEY,UAAU,iBAAiB,MAAM;;;;;;;;uBA8D68N,CAAC;;;;;;qBAxCh/N,GAAG,iBAAiB,MAAM;EAuCnD"}
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/store/tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EACL,KAAK,GAAG,EACR,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAA;AAKxC,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,eAAe,EAAE,OAAO;;;;;;;;;uBA8Fy4N,CAAC;;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;;;;2BAAD,CAAC;;;;;;;;;;EAjFj8N;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,EACf,WAAW,GACZ,EAAE,YAAY;sBAEY,UAAU,iBAAiB,MAAM;;;;;;;;uBAkEq4N,CAAC;;;;;;qBA5Cx6N,GAAG,iBAAiB,MAAM;EA2CnD"}

package/dist/store/tags.js

@@ -1,57 +1,59 @@
-import { tagSchema as h } from "@scalar/oas-utils/entities/spec";
-import { LS_KEYS as o, schemaModel as T } from "@scalar/oas-utils/helpers";
-import { mutationFactory as A } from "@scalar/object-utils/mutator-record";
+import { tagSchema as o } from "@scalar/oas-utils/entities/spec";
+import { LS_KEYS as T, schemaModel as A } from "@scalar/oas-utils/helpers";
+import { mutationFactory as p } from "@scalar/object-utils/mutator-record";
 import { reactive as g } from "vue";
-function G(n) {
-  const d = g({}), i = A(
+function I(a) {
+  const d = g({}), i = p(
     d,
     g({}),
-    n && o.TAG
+    a && T.TAG
   );
   return {
     tags: d,
     tagMutators: i
   };
 }
-function I({
-  collectionMutators: n,
+function L({
+  collectionMutators: a,
   collections: d,
   requests: i,
-  requestMutators: u,
+  requestMutators: c,
   tagMutators: f
 }) {
-  return { addTag: (r, t) => {
-    const a = d[t], e = T(r, h, !1);
-    return e ? (n.edit(t, "tags", [
-      ...a.tags,
+  return { addTag: (t, n) => {
+    const r = d[n], e = A(t, o, !1);
+    return !e || !r ? console.error("INVALID TAG DATA", t) : (a.edit(n, "tags", [
+      ...r.tags,
       e.uid
-    ]), n.edit(t, "children", [
-      ...a.children,
+    ]), a.edit(n, "children", [
+      ...r.children,
       e.uid
-    ]), f.add(e), e) : console.error("INVALID TAG DATA", r);
-  }, deleteTag: (r, t) => {
-    const a = d[t];
-    n.edit(
-      t,
+    ]), f.add(e), e);
+  }, deleteTag: (t, n) => {
+    const r = d[n];
+    r && (a.edit(
+      n,
       "tags",
-      a.tags.filter((e) => e !== r.uid)
-    ), n.edit(
-      t,
+      r.tags.filter((e) => e !== t.uid)
+    ), a.edit(
+      n,
       "children",
-      a.children.filter((e) => e !== r.uid)
-    ), r.children.forEach((e) => {
-      var m;
-      const s = (m = i[e].tags) == null ? void 0 : m.filter(
-        (c) => c !== r.name
+      r.children.filter((e) => e !== t.uid)
+    ), t.children.forEach((e) => {
+      var u;
+      const m = i[e];
+      if (!m) return;
+      const s = (u = m.tags) == null ? void 0 : u.filter(
+        (h) => h !== t.name
       );
-      u.edit(e, "tags", s), !(s != null && s.length) && !a.children.includes(e) && n.edit(t, "children", [
-        ...a.children,
+      c.edit(e, "tags", s), !(s != null && s.length) && !r.children.includes(e) && a.edit(n, "children", [
+        ...r.children,
         e
       ]);
-    }), f.delete(r.uid);
+    }), f.delete(t.uid));
   } };
 }
 export {
-  G as createStoreTags,
-  I as extendedTagDataFactory
+  I as createStoreTags,
+  L as extendedTagDataFactory
 };