@scalar/api-client 2.17.7 → 2.18.0

package/dist/v2/blocks/scalar-auth-selector-block/components/OAuthScopesInput.vue.js

@@ -1,115 +1,122 @@
-import { defineComponent as A, computed as v, createBlock as d, openBlock as n, unref as s, withCtx as o, createElementVNode as a, createVNode as r, normalizeClass as B, toDisplayString as p, createCommentVNode as u, withModifiers as g, createTextVNode as m, createElementBlock as w, Fragment as O, renderList as j } from "vue";
-import { Disclosure as z, DisclosureButton as N, DisclosurePanel as T } from "@headlessui/vue";
-import { ScalarButton as k, ScalarIcon as $ } from "@scalar/components";
+import { defineComponent as T, computed as y, createBlock as p, openBlock as a, unref as s, withCtx as l, createElementVNode as r, createVNode as c, normalizeClass as j, toDisplayString as d, createCommentVNode as u, withModifiers as m, createTextVNode as f, createElementBlock as b, Fragment as z, renderList as B } from "vue";
+import { Disclosure as N, DisclosureButton as M, DisclosurePanel as $ } from "@headlessui/vue";
+import { useModal as E, ScalarButton as S, ScalarIcon as I } from "@scalar/components";
+import P from "./OAuthScopesAddModal.vue.js";
 import C from "../../../../components/DataTable/DataTableCell.vue.js";
-import E from "../../../../components/DataTable/DataTableRow.vue.js";
-import I from "../../../../components/DataTable/DataTableCheckbox.vue.js";
-const R = { class: "flex h-fit w-full" }, U = { class: "flex-1" }, F = { class: "flex items-center gap-1.75" }, L = {
+import R from "../../../../components/DataTable/DataTableRow.vue.js";
+import U from "../../../../components/DataTable/DataTableCheckbox.vue.js";
+const F = { class: "flex h-fit w-full" }, L = { class: "flex-1" }, _ = { class: "flex items-center gap-1.75" }, q = {
   class: "grid auto-rows-auto",
   style: { gridTemplateColumns: "1fr auto" }
-}, M = { key: 0 }, P = { class: "font-code text-xs" }, X = /* @__PURE__ */ A({
+}, G = { class: "font-code text-xs" }, H = { key: 0 }, ee = /* @__PURE__ */ T({
   __name: "OAuthScopesInput",
   props: {
+    flowType: {},
     flow: {},
     selectedScopes: {}
   },
   emits: ["update:selectedScopes"],
-  setup(c, { emit: b }) {
-    const i = b, y = v(
-      () => Object.entries(c.flow?.scopes ?? {}).map(([e, t]) => ({
-        id: e,
-        label: e,
-        description: t
+  setup(n, { emit: A }) {
+    const i = A, V = y(
+      () => Object.entries(n.flow?.scopes ?? {}).map(([t, e]) => ({
+        id: t,
+        label: t,
+        description: e
       }))
-    ), f = v(
-      () => c.selectedScopes.length === Object.keys(c.flow?.scopes ?? {}).length
+    ), h = y(
+      () => n.selectedScopes.length === Object.keys(n.flow?.scopes ?? {}).length
     );
-    function S(e, t) {
-      if (t)
+    function w(t, e) {
+      if (e)
         return i("update:selectedScopes", {
-          scopes: Array.from(/* @__PURE__ */ new Set([...c.selectedScopes, e]))
+          scopes: Array.from(/* @__PURE__ */ new Set([...n.selectedScopes, t]))
         });
       i("update:selectedScopes", {
-        scopes: c.selectedScopes.filter((l) => l !== e)
+        scopes: n.selectedScopes.filter((o) => o !== t)
       });
     }
-    const _ = () => {
-      i("update:selectedScopes", { scopes: Object.keys(c.flow?.scopes ?? {}) });
-    }, V = () => {
-      i("update:selectedScopes", { scopes: [] });
-    };
-    return (e, t) => (n(), d(s(C), { class: "h-auto !max-h-[initial] min-h-8 items-center" }, {
-      default: o(() => [
-        a("div", R, [
-          t[2] || (t[2] = a("div", { class: "text-c-1 h-full items-center" }, null, -1)),
-          r(s(z), {
+    const D = () => i("update:selectedScopes", { scopes: Object.keys(n.flow?.scopes ?? {}) }), O = () => i("update:selectedScopes", { scopes: [] }), v = E();
+    return (t, e) => (a(), p(s(C), { class: "h-auto !max-h-[initial] min-h-8 items-center" }, {
+      default: l(() => [
+        r("div", F, [
+          e[5] || (e[5] = r("div", { class: "text-c-1 h-full items-center" }, null, -1)),
+          c(s(N), {
             as: "div",
             class: "bl flex w-full flex-col"
           }, {
-            default: o(() => [
-              r(s(N), {
-                class: B([
+            default: l(() => [
+              c(s(M), {
+                class: j([
                   "group/scopes-accordion hover:text-c-1 flex h-auto min-h-8 cursor-pointer items-center gap-1.5 pr-2.25 pl-3 text-left",
-                  (e.selectedScopes.length || 0) > 0 ? "text-c-1" : "text-c-3"
+                  (t.selectedScopes.length || 0) > 0 ? "text-c-1" : "text-c-3"
                 ])
               }, {
-                default: o(({ open: l }) => [
-                  a("div", U, " Scopes Selected " + p(e.selectedScopes.length || 0) + " / " + p(Object.keys(e.flow?.scopes ?? {}).length || 0), 1),
-                  a("div", F, [
-                    f.value ? (n(), d(s(k), {
+                default: l(({ open: o }) => [
+                  r("div", L, " Scopes Selected " + d(t.selectedScopes.length || 0) + " / " + d(Object.keys(t.flow?.scopes ?? {}).length || 0), 1),
+                  r("div", _, [
+                    c(s(S), {
+                      class: "pr-0.75 pl-1 transition-none",
+                      size: "sm",
+                      variant: "ghost",
+                      onClick: e[0] || (e[0] = m((g) => s(v).show(), ["stop"]))
+                    }, {
+                      default: l(() => [...e[2] || (e[2] = [
+                        f(" Add Scope ", -1)
+                      ])]),
+                      _: 1
+                    }),
+                    h.value ? (a(), p(s(S), {
                       key: 0,
                       class: "pr-0.75 pl-1 transition-none",
                       size: "sm",
                       variant: "ghost",
-                      onClick: g(V, ["stop"])
+                      onClick: m(O, ["stop"])
                     }, {
-                      default: o(() => [...t[0] || (t[0] = [
-                        m(" Deselect All ", -1)
+                      default: l(() => [...e[3] || (e[3] = [
+                        f(" Deselect All ", -1)
                       ])]),
                       _: 1
                     })) : u("", !0),
-                    f.value ? u("", !0) : (n(), d(s(k), {
+                    h.value ? u("", !0) : (a(), p(s(S), {
                       key: 1,
                       class: "pr-0.75 pl-1 transition-none",
                       size: "sm",
                       variant: "ghost",
-                      onClick: g(_, ["stop"])
+                      onClick: m(D, ["stop"])
                     }, {
-                      default: o(() => [...t[1] || (t[1] = [
-                        m(" Select All ", -1)
+                      default: l(() => [...e[4] || (e[4] = [
+                        f(" Select All ", -1)
                       ])]),
                       _: 1
                     })),
-                    r(s($), {
+                    c(s(I), {
                       class: "text-c-3 group-hover/scopes-accordion:text-c-2",
-                      icon: l ? "ChevronDown" : "ChevronRight",
+                      icon: o ? "ChevronDown" : "ChevronRight",
                       size: "md"
                     }, null, 8, ["icon"])
                   ])
                 ]),
                 _: 1
               }, 8, ["class"]),
-              r(s(T), { as: "template" }, {
-                default: o(() => [
-                  a("table", L, [
-                    (n(!0), w(O, null, j(y.value, ({ id: l, label: D, description: h }) => (n(), d(s(E), {
-                      key: l,
+              c(s($), { as: "template" }, {
+                default: l(() => [
+                  r("table", q, [
+                    (a(!0), b(z, null, B(V.value, ({ id: o, label: g, description: x }) => (a(), p(s(R), {
+                      key: o,
                       class: "text-c-2",
-                      onClick: (x) => S(l, !e.selectedScopes.includes(l))
+                      onClick: (k) => w(o, !t.selectedScopes.includes(o))
                     }, {
-                      default: o(() => [
-                        r(s(C), { class: "hover:text-c-1 box-border !max-h-[initial] w-full cursor-pointer px-3 py-1.5" }, {
-                          default: o(() => [
-                            h ? (n(), w("div", M, [
-                              a("span", P, p(D), 1),
-                              m(" – " + p(h), 1)
-                            ])) : u("", !0)
+                      default: l(() => [
+                        c(s(C), { class: "hover:text-c-1 box-border !max-h-[initial] w-full cursor-pointer px-3 py-1.5" }, {
+                          default: l(() => [
+                            r("span", G, d(g), 1),
+                            x ? (a(), b("span", H, "   – " + d(x), 1)) : u("", !0)
                           ]),
                           _: 2
                         }, 1024),
-                        r(s(I), {
-                          modelValue: e.selectedScopes.includes(l),
-                          "onUpdate:modelValue": (x) => S(l, x)
+                        c(s(U), {
+                          modelValue: t.selectedScopes.includes(o),
+                          "onUpdate:modelValue": (k) => w(o, k)
                         }, null, 8, ["modelValue", "onUpdate:modelValue"])
                       ]),
                       _: 2
@@ -121,12 +128,20 @@ const R = { class: "flex h-fit w-full" }, U = { class: "flex-1" }, F = { class:
             ]),
             _: 1
           })
-        ])
+        ]),
+        c(P, {
+          scopes: Object.keys(t.flow.scopes ?? {}),
+          state: s(v),
+          onSubmit: e[1] || (e[1] = (o) => i("update:selectedScopes", {
+            scopes: t.selectedScopes,
+            newScopePayload: { ...o, flowType: t.flowType }
+          }))
+        }, null, 8, ["scopes", "state"])
       ]),
       _: 1
     }));
   }
 });
 export {
-  X as default
+  ee as default
 };

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue.d.ts

@@ -14,6 +14,11 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
         id: string[];
         name: string;
         scopes: string[];
+        newScopePayload?: {
+            name: string;
+            description: string;
+            flowType: keyof import("@scalar/workspace-store/schemas/v3.1/strict/oauthflows").OAuthFlowsObject;
+        };
         meta: import("@scalar/workspace-store/mutators").AuthMeta;
     }, "meta">) => any;
     "update:securityScheme": (payload: ({
@@ -40,7 +45,6 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 authorizationUrl?: string | undefined;
                 'x-scalar-secret-redirect-uri'?: string | undefined;
             } | undefined;
@@ -58,11 +62,11 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-username'?: string | undefined;
                 'x-scalar-secret-password'?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
             clientCredentials?: {
                 refreshUrl?: string | undefined;
@@ -78,9 +82,9 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
             authorizationCode?: {
                 refreshUrl?: string | undefined;
@@ -96,12 +100,12 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 authorizationUrl?: string | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
                 'x-scalar-secret-redirect-uri'?: string | undefined;
                 'x-usePkce'?: "SHA-256" | "plain" | "no" | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
         } | undefined;
     })) => any;
@@ -110,6 +114,11 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
         id: string[];
         name: string;
         scopes: string[];
+        newScopePayload?: {
+            name: string;
+            description: string;
+            flowType: keyof import("@scalar/workspace-store/schemas/v3.1/strict/oauthflows").OAuthFlowsObject;
+        };
         meta: import("@scalar/workspace-store/mutators").AuthMeta;
     }, "meta">) => any) | undefined;
     "onUpdate:securityScheme"?: ((payload: ({
@@ -136,7 +145,6 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 authorizationUrl?: string | undefined;
                 'x-scalar-secret-redirect-uri'?: string | undefined;
             } | undefined;
@@ -154,11 +162,11 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-username'?: string | undefined;
                 'x-scalar-secret-password'?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
             clientCredentials?: {
                 refreshUrl?: string | undefined;
@@ -174,9 +182,9 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
             authorizationCode?: {
                 refreshUrl?: string | undefined;
@@ -192,12 +200,12 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
                     [x: string]: string | undefined;
                 } | undefined;
                 'x-tokenName'?: string | undefined;
-                'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 authorizationUrl?: string | undefined;
                 tokenUrl?: string | undefined;
                 'x-scalar-secret-client-secret'?: string | undefined;
                 'x-scalar-secret-redirect-uri'?: string | undefined;
                 'x-usePkce'?: "SHA-256" | "plain" | "no" | undefined;
+                'x-scalar-credentials-location'?: "header" | "body" | undefined;
             } | undefined;
         } | undefined;
     })) => any) | undefined;

package/dist/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestAuthTab.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue"],"names":[],"mappings":"AAmTA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,yBAAyB,EAEzB,YAAY,EACb,MAAM,8DAA8D,CAAA;AAcrE,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,kBAAkB,CAAA;IAC/B,yFAAyF;IACzF,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,uBAAuB,EAAE,yBAAyB,CAAA;IAClD,eAAe,EAAE,WAAW,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAA;IACjE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;CAC5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmiBF,wBAOG"}
+{"version":3,"file":"RequestAuthTab.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/components/RequestAuthTab.vue"],"names":[],"mappings":"AAmTA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAA;AACnH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,yBAAyB,EAEzB,YAAY,EACb,MAAM,8DAA8D,CAAA;AAcrE,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,kBAAkB,CAAA;IAC/B,yFAAyF;IACzF,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,uBAAuB,EAAE,yBAAyB,CAAA;IAClD,eAAe,EAAE,WAAW,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC,CAAA;IACjE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;CAC5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmiBF,wBAOG"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.d.ts

@@ -1,7 +1,7 @@
 import type { OAuthFlowsObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import type { ErrorResponse } from '../../../../libs/errors.js';
 /** Oauth2 security schemes which are not implicit */
-type NonImplicitFlow = Omit<OAuthFlowsObject, 'implicit'>;
+type NonImplicitFlows = Omit<OAuthFlowsObject, 'implicit'>;
 type PKCEState = {
     codeVerifier: string;
     codeChallenge: string;
@@ -25,7 +25,7 @@ proxyUrl: string) => Promise<ErrorResponse<string>>;
  * Makes the BE authorization call to grab the token server to server
  * Used for clientCredentials and authorizationCode
  */
-export declare const authorizeServers: (flows: NonImplicitFlow, type: keyof NonImplicitFlow, scopes: string, { code, pkce, proxyUrl, }: {
+export declare const authorizeServers: (flows: NonImplicitFlows, type: keyof NonImplicitFlows, scopes: string, { code, pkce, proxyUrl, }: {
     code?: string;
     pkce?: PKCEState | null;
     proxyUrl?: string;

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGlH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,qDAAqD;AACrD,KAAK,eAAe,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAA;AAEzD,KAAK,SAAS,GAAG;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAA;AAgBD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAU,UAAU,MAAM,EAAE,UAAU,SAAS,GAAG,OAAO,KAAG,OAAO,CAAC,MAAM,CAkB3G,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,gBAAgB,MAAM,EAAE;AACxB,wEAAwE;AACxE,cAAc,YAAY,GAAG,IAAI;AACjC,kCAAkC;AAClC,UAAU,MAAM,KACf,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAmL/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,eAAe,EACtB,MAAM,MAAM,eAAe,EAC3B,QAAQ,MAAM,EACd,2BAIG;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,YAAK,EACN,cAAc,YAAY,GAAG,IAAI,KAChC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CA+F/B,CAAA"}
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/v2/blocks/scalar-auth-selector-block/helpers/oauth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGlH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,qDAAqD;AACrD,KAAK,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAA;AAE1D,KAAK,SAAS,GAAG;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAA;AAgBD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAU,UAAU,MAAM,EAAE,UAAU,SAAS,GAAG,OAAO,KAAG,OAAO,CAAC,MAAM,CAkB3G,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,gBAAgB,MAAM,EAAE;AACxB,wEAAwE;AACxE,cAAc,YAAY,GAAG,IAAI;AACjC,kCAAkC;AAClC,UAAU,MAAM,KACf,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAiL/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,gBAAgB,EACvB,MAAM,MAAM,gBAAgB,EAC5B,QAAQ,MAAM,EACd,2BAIG;IACD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,YAAK,EACN,cAAc,YAAY,GAAG,IAAI,KAChC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAwF/B,CAAA"}

package/dist/v2/blocks/scalar-auth-selector-block/helpers/oauth.js

@@ -1,128 +1,130 @@
-import { makeUrlAbsolute as A } from "@scalar/helpers/url/make-url-absolute";
-import { shouldUseProxy as b } from "@scalar/oas-utils/helpers";
-import { encode as C, fromUint8Array as S } from "js-base64";
-const E = () => {
-  const r = new Uint8Array(32);
-  return crypto.getRandomValues(r), S(r, !0);
-}, z = async (r, t) => {
-  if (t === "plain")
-    return r;
+import { makeUrlAbsolute as b } from "@scalar/helpers/url/make-url-absolute";
+import { shouldUseProxy as E } from "@scalar/oas-utils/helpers";
+import { encode as A, fromUint8Array as C } from "js-base64";
+const S = () => {
+  const s = new Uint8Array(32);
+  return crypto.getRandomValues(s), C(s, !0);
+}, z = async (s, e) => {
+  if (e === "plain")
+    return s;
   if (typeof crypto?.subtle?.digest != "function")
-    return console.warn("SHA-256 is only supported when using https, using a plain text code challenge instead."), r;
-  const l = new TextEncoder().encode(r), w = await crypto.subtle.digest("SHA-256", l);
-  return S(new Uint8Array(w), !0);
-}, $ = async (r, t, p, l, w) => {
-  const d = r[t];
+    return console.warn("SHA-256 is only supported when using https, using a plain text code challenge instead."), s;
+  const l = new TextEncoder().encode(s), f = await crypto.subtle.digest("SHA-256", l);
+  return C(new Uint8Array(f), !0);
+}, L = async (s, e, g, l, f) => {
+  const d = s[e];
   try {
     if (!d)
       return [new Error("Flow not found"), null];
-    const f = p.join(" ");
-    if (t === "clientCredentials" || t === "password")
+    const m = g.join(" ");
+    if (e === "clientCredentials" || e === "password")
       return U(
-        r,
-        t,
-        f,
+        s,
+        e,
+        m,
         {
-          proxyUrl: w
+          proxyUrl: f
         },
         l
       );
-    const e = (Math.random() + 1).toString(36).substring(2, 10), a = A(r[t].authorizationUrl, {
+    const t = (Math.random() + 1).toString(36).substring(2, 10), a = b(s[e].authorizationUrl, {
       baseUrl: l?.url
     }), n = new URL(a);
-    let o = null;
-    if (t === "implicit")
+    let c = null;
+    if (e === "implicit")
       n.searchParams.set("response_type", "token");
-    else if (t === "authorizationCode") {
-      const s = r[t];
-      if (n.searchParams.set("response_type", "code"), s["x-usePkce"] !== "no") {
-        const c = E(), i = await z(c, s["x-usePkce"]);
-        o = {
-          codeVerifier: c,
-          codeChallenge: i,
-          codeChallengeMethod: s["x-usePkce"] === "SHA-256" ? "S256" : "plain"
-        }, n.searchParams.set("code_challenge", i), n.searchParams.set("code_challenge_method", o.codeChallengeMethod);
+    else if (e === "authorizationCode") {
+      const r = s[e];
+      if (n.searchParams.set("response_type", "code"), r["x-usePkce"] !== "no") {
+        const o = S(), u = await z(o, r["x-usePkce"]);
+        c = {
+          codeVerifier: o,
+          codeChallenge: u,
+          codeChallengeMethod: r["x-usePkce"] === "SHA-256" ? "S256" : "plain"
+        }, n.searchParams.set("code_challenge", u), n.searchParams.set("code_challenge_method", c.codeChallengeMethod);
       }
     }
-    const m = r[t];
-    if (m["x-scalar-secret-redirect-uri"].startsWith("/")) {
-      const s = l?.url || window.location.origin + window.location.pathname, c = new URL(m["x-scalar-secret-redirect-uri"], s).toString();
-      n.searchParams.set("redirect_uri", c);
+    const i = s[e];
+    if (i["x-scalar-secret-redirect-uri"].startsWith("/")) {
+      const r = l?.url || window.location.origin + window.location.pathname, o = new URL(i["x-scalar-secret-redirect-uri"], r).toString();
+      n.searchParams.set("redirect_uri", o);
     } else
-      n.searchParams.set("redirect_uri", m["x-scalar-secret-redirect-uri"]);
-    d["x-scalar-security-query"] && Object.keys(d["x-scalar-security-query"]).forEach((s) => {
-      const c = d["x-scalar-security-query"]?.[s];
-      c && n.searchParams.set(s, c);
-    }), n.searchParams.set("client_id", d["x-scalar-secret-client-id"]), n.searchParams.set("state", e), f && n.searchParams.set("scope", f);
-    const u = window.open(n, "openAuth2Window", "left=100,top=100,width=800,height=600");
-    return u ? new Promise((s) => {
-      const c = setInterval(() => {
-        let i = null, g = null, x = null, P = null;
+      n.searchParams.set("redirect_uri", i["x-scalar-secret-redirect-uri"]);
+    d["x-scalar-security-query"] && Object.keys(d["x-scalar-security-query"]).forEach((r) => {
+      const o = d["x-scalar-security-query"]?.[r];
+      o && n.searchParams.set(r, o);
+    }), n.searchParams.set("client_id", d["x-scalar-secret-client-id"]), n.searchParams.set("state", t), m && n.searchParams.set("scope", m);
+    const h = window.open(n, "openAuth2Window", "left=100,top=100,width=800,height=600");
+    return h ? new Promise((r) => {
+      const o = setInterval(() => {
+        let u = null, p = null, x = null, _ = null;
         try {
-          const h = new URL(u.location.href).searchParams, k = d["x-tokenName"] || "access_token";
-          i = h.get(k), g = h.get("code"), x = h.get("error"), P = h.get("error_description");
-          const y = new URLSearchParams(u.location.href.split("#")[1]);
-          i ||= y.get(k), g ||= y.get("code"), x ||= y.get("error"), P ||= y.get("error_description");
+          const w = new URL(h.location.href).searchParams, k = d["x-tokenName"] || "access_token";
+          u = w.get(k), p = w.get("code"), x = w.get("error"), _ = w.get("error_description");
+          const P = new URLSearchParams(h.location.href.split("#")[1]);
+          u ||= P.get(k), p ||= P.get("code"), x ||= P.get("error"), _ ||= P.get("error_description");
         } catch {
         }
-        if (u.closed || i || g || x)
-          if (clearInterval(c), u.close(), x)
-            s([new Error(`OAuth error: ${x}${P ? ` (${P})` : ""}`), null]);
-          else if (i) {
-            const h = u.location.href.match(/state=([^&]*)/)?.[1];
-            s(h === e ? [null, i] : [new Error("State mismatch"), null]);
-          } else g && t === "authorizationCode" ? new URL(u.location.href).searchParams.get("state") === e ? U(
-            r,
-            t,
-            f,
+        if (h.closed || u || p || x)
+          if (clearInterval(o), h.close(), x)
+            r([new Error(`OAuth error: ${x}${_ ? ` (${_})` : ""}`), null]);
+          else if (u) {
+            const w = h.location.href.match(/state=([^&]*)/)?.[1];
+            r(w === t ? [null, u] : [new Error("State mismatch"), null]);
+          } else p && e === "authorizationCode" ? new URL(h.location.href).searchParams.get("state") === t ? U(
+            s,
+            e,
+            m,
             {
-              code: g,
-              pkce: o,
-              proxyUrl: w
+              code: p,
+              pkce: c,
+              proxyUrl: f
             },
             l
-          ).then(s) : s([new Error("State mismatch"), null]) : (clearInterval(c), s([new Error("Window was closed without granting authorization"), null]));
+          ).then(r) : r([new Error("State mismatch"), null]) : (clearInterval(o), r([new Error("Window was closed without granting authorization"), null]));
       }, 200);
     }) : [new Error("Failed to open auth window"), null];
   } catch {
     return [new Error("Failed to authorize oauth2 flow"), null];
   }
-}, U = async (r, t, p, {
+}, U = async (s, e, g, {
   code: l,
-  pkce: w,
+  pkce: f,
   proxyUrl: d
-} = {}, f) => {
-  const e = r[t];
-  if (!e)
+} = {}, m) => {
+  const t = s[e];
+  if (!t)
     return [new Error("OAuth2 flow was not defined"), null];
   const a = new URLSearchParams();
-  if (a.set("client_id", e["x-scalar-secret-client-id"]), p && (t === "clientCredentials" || t === "password") && a.set("scope", p), e["x-scalar-secret-client-secret"] && (!e["x-scalar-credentials-location"] || e["x-scalar-credentials-location"] === "body") && a.set("client_secret", e["x-scalar-secret-client-secret"]), "x-scalar-secret-redirect-uri" in e && e["x-scalar-secret-redirect-uri"] && a.set("redirect_uri", e["x-scalar-secret-redirect-uri"]), l)
-    a.set("code", l), a.set("grant_type", "authorization_code"), w && a.set("code_verifier", w.codeVerifier);
-  else if (t === "password") {
-    const o = r[t];
-    a.set("grant_type", "password"), a.set("username", o["x-scalar-secret-username"]), a.set("password", o["x-scalar-secret-password"]);
+  g && (e === "clientCredentials" || e === "password") && a.set("scope", g);
+  const n = t["x-scalar-credentials-location"] === "body";
+  if (n && (a.set("client_id", t["x-scalar-secret-client-id"]), a.set("client_secret", t["x-scalar-secret-client-secret"])), "x-scalar-secret-redirect-uri" in t && t["x-scalar-secret-redirect-uri"] && a.set("redirect_uri", t["x-scalar-secret-redirect-uri"]), l)
+    a.set("code", l), a.set("grant_type", "authorization_code"), f && a.set("code_verifier", f.codeVerifier);
+  else if (e === "password") {
+    const c = s[e];
+    a.set("grant_type", "password"), a.set("username", c["x-scalar-secret-username"]), a.set("password", c["x-scalar-secret-password"]);
   } else
     a.set("grant_type", "client_credentials");
-  e["x-scalar-security-body"] && Object.entries(e["x-scalar-security-body"]).forEach(([o, m]) => {
-    m && a.set(o, m);
+  t["x-scalar-security-body"] && Object.entries(t["x-scalar-security-body"]).forEach(([c, i]) => {
+    i && a.set(c, i);
   });
   try {
-    const o = {
+    const c = {
       "Content-Type": "application/x-www-form-urlencoded"
     };
-    e["x-scalar-secret-client-secret"] && (!e["x-scalar-credentials-location"] || e["x-scalar-credentials-location"] === "header") && (o.Authorization = `Basic ${C(`${e["x-scalar-secret-client-id"]}:${e["x-scalar-secret-client-secret"]}`)}`);
-    const _ = A(e.tokenUrl, { baseUrl: f?.url }), u = b(d, _) ? `${d}?${new URLSearchParams([["scalar_url", _]]).toString()}` : _, c = await (await fetch(u, {
+    n || (c.Authorization = `Basic ${A(`${t["x-scalar-secret-client-id"]}:${t["x-scalar-secret-client-secret"]}`)}`);
+    const i = b(t.tokenUrl, { baseUrl: m?.url }), y = E(d, i) ? `${d}?${new URLSearchParams([["scalar_url", i]]).toString()}` : i, r = await (await fetch(y, {
       method: "POST",
-      headers: o,
+      headers: c,
       body: a
-    })).json(), i = e["x-tokenName"] || "access_token";
-    return [null, c[i]];
+    })).json(), o = t["x-tokenName"] || "access_token";
+    return [null, r[o]];
   } catch {
     return [new Error("Failed to get an access token. Please check your credentials."), null];
   }
 };
 export {
-  $ as authorizeOauth2,
+  L as authorizeOauth2,
   U as authorizeServers,
   z as generateCodeChallenge
 };