@scalar/api-client 2.1.26 → 2.1.28

package/dist/store/requests.js

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

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

@@ -1,5 +1,5 @@
 import type { StoreContext } from '../store/store-context';
-import { type SecurityScheme, type SecuritySchemePayload } from '@scalar/oas-utils/entities/spec';
+import { type SecuritySchemePayload } from '@scalar/oas-utils/entities/spec';
 /** Create storage entities for security schemes */
 export declare function createStoreSecuritySchemes(useLocalStorage: boolean): {
     securitySchemes: Record<string, {
@@ -556,6 +556,6 @@ export declare function extendedSecurityDataFactory({ securitySchemeMutators, co
         'x-scalar-client-id': string;
         description?: string | undefined;
     };
-    deleteSecurityScheme: (scheme: SecurityScheme) => void;
+    deleteSecurityScheme: (schemeUid: string) => void;
 };
 //# sourceMappingURL=security-schemes.d.ts.map

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,EACL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAG3B,MAAM,iCAAiC,CAAA;AAKxC,mDAAmD;AACnD,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlE;AAED,sDAAsD;AACtD,wBAAgB,2BAA2B,CAAC,EAC1C,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;iCAGF,qBAAqB,iBAEf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA0Be,cAAc;EA+CrD"}
+{"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,EAG3B,MAAM,iCAAiC,CAAA;AAKxC,mDAAmD;AACnD,wBAAgB,0BAA0B,CAAC,eAAe,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlE;AAED,sDAAsD;AACtD,wBAAgB,2BAA2B,CAAC,EAC1C,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;iCAGF,qBAAqB,iBAEf,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA0BkB,MAAM;EA6ChD"}

package/dist/store/security-schemes.js

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

package/dist/store/servers.d.ts

@@ -4,8 +4,8 @@ import { type ServerPayload } from '@scalar/oas-utils/entities/spec';
 export declare function createStoreServers(useLocalStorage: boolean): {
     servers: Record<string, {
         uid: string;
+        url: string;
         description?: string | undefined;
-        url?: string | undefined;
         variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
             enum?: [string, ...string[]];
         }> | undefined;
@@ -13,8 +13,8 @@ export declare function createStoreServers(useLocalStorage: boolean): {
     serverMutators: {
         add: (item: {
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
@@ -22,52 +22,52 @@ export declare function createStoreServers(useLocalStorage: boolean): {
         delete: (uid: string) => void;
         set: (item: {
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }) => void;
         edit: <P extends "url" | "description" | "uid" | "variables" | `variables.${string}`>(uid: string, path: P, value: P extends "url" | "description" | "uid" | "variables" ? {
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }[P] : P extends `${infer K}.${infer R}` ? K extends "url" | "description" | "uid" | "variables" ? R extends import("@scalar/object-utils/nested").Path<{
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }[K]> ? import("@scalar/object-utils/nested").PathValue<{
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }[K], R> : never : K extends `${number}` ? never : never : P extends `${number}` ? never : never) => void;
         untrackedEdit: <P extends "url" | "description" | "uid" | "variables" | `variables.${string}`>(uid: string, path: P, value: P extends "url" | "description" | "uid" | "variables" ? {
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }[P] : P extends `${infer K}.${infer R}` ? K extends "url" | "description" | "uid" | "variables" ? R extends import("@scalar/object-utils/nested").Path<{
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
         }[K]> ? import("@scalar/object-utils/nested").PathValue<{
             uid: string;
+            url: string;
             description?: string | undefined;
-            url?: string | undefined;
             variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
                 enum?: [string, ...string[]];
             }> | undefined;
@@ -80,8 +80,8 @@ export declare function createStoreServers(useLocalStorage: boolean): {
 export declare function extendedServerDataFactory({ serverMutators, collections, collectionMutators, requests, requestMutators, }: StoreContext): {
     addServer: (payload: ServerPayload, parentUid: string) => {
         uid: string;
+        url: string;
         description?: string | undefined;
-        url?: string | undefined;
         variables?: Record<string, Omit<import("@scalar/openapi-types").OpenAPIV3_1.ServerVariableObject, "enum"> & {
             enum?: [string, ...string[]];
         }> | undefined;

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;;;;;;gBAqEqtC,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;;oBAAD,CAAC;;;;;;EAxDhxC;AAED,6CAA6C;AAC7C,wBAAgB,yBAAyB,CAAC,EACxC,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,eAAe,GAChB,EAAE,YAAY;yBAKe,aAAa,aAAa,MAAM;;;;;gBA0CktC,CAAC;;;8BAjB9uC,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;;;;;;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"}