@scalar/api-client 1.3.20 → 2.0.1

package/dist/router.js

@@ -0,0 +1,109 @@
+import { computed as i } from "vue";
+import { createRouter as c, createWebHistory as l, createMemoryHistory as m } from "vue-router";
+var u = /* @__PURE__ */ ((e) => (e.Request = "request", e.Example = "example", e.Cookies = "cookies", e.Collection = "collection", e.Schema = "schema", e.Environment = "environment", e.Server = "server", e))(u || {});
+const s = [
+  { path: "/", redirect: "/request/default" },
+  {
+    path: "/request",
+    redirect: "/request/default"
+  },
+  {
+    path: "/request/:request",
+    component: () => import("./views/Request/Request.vue.js")
+  },
+  {
+    path: "/request/:request/example/:example",
+    component: () => import("./views/Request/Request.vue.js")
+  }
+], p = [
+  ...s,
+  {
+    path: "/collection",
+    redirect: "/collection/default"
+  },
+  {
+    name: "collection",
+    path: "/collection/:collection",
+    component: () => import("./views/Collection/Collection.vue.js"),
+    children: [
+      // Nested collection request
+      {
+        path: "request/request",
+        component: () => import("./views/Request/Request.vue.js")
+      }
+    ]
+  },
+  /** Components will map to each section of the spec components object */
+  {
+    path: "/components",
+    redirect: "/components/schemas/default",
+    children: [
+      {
+        path: "schemas/:schema",
+        component: () => import("./views/Components/Schemas/Schemas.vue.js")
+      }
+    ]
+  },
+  {
+    path: "/environment",
+    redirect: "/environment/default"
+  },
+  {
+    path: "/environment/:environment",
+    component: () => import("./views/Environment/Environment.vue.js")
+  },
+  {
+    path: "/cookies",
+    redirect: "/cookies/default"
+  },
+  {
+    path: "/cookies/:cookies",
+    component: () => import("./views/Cookies/Cookies.vue.js")
+  },
+  {
+    path: "/servers",
+    redirect: "/servers/default"
+  },
+  {
+    path: "/servers/:server",
+    component: () => import("./views/Servers/Servers.vue.js")
+  }
+], t = c({
+  history: l(),
+  routes: p
+}), a = c({
+  history: m(),
+  routes: s
+}), f = i(() => {
+  const e = {
+    collection: "default",
+    environment: "default",
+    request: "default",
+    example: "default",
+    schema: "default",
+    cookies: "default",
+    server: "default"
+  }, o = a.currentRoute.value.matched.length ? a.currentRoute.value : t.currentRoute.value;
+  return o && Object.values(u).forEach((r) => {
+    o.params[r] && (e[r] = o.params[r]);
+  }), e;
+});
+function d(e, o) {
+  var r, n;
+  t.currentRoute.value && // If the item is missing then we know the UID is no longer in use and redirect to the default
+  !o && ((r = t.currentRoute.value) != null && r.params[e]) && ((n = t.currentRoute.value) == null ? void 0 : n.params[e]) !== "default" && // We only redirect if the key is missing for the matching route
+  t.currentRoute.value.path.includes(e) && t.push({
+    params: {
+      ...t.currentRoute.value.params,
+      [e]: "default"
+    }
+  });
+}
+export {
+  u as PathId,
+  f as activeRouterParams,
+  a as clientRouter,
+  s as clientRoutes,
+  d as fallbackMissingParams,
+  t as router
+};

package/dist/store/topNav.d.ts

@@ -0,0 +1,433 @@
+import { type Route } from '../constants.js';
+/**
+ * adding a nav item sets the new index and nav item
+ * based on the route
+ */
+declare function addNavItem(): void;
+declare function setNavItemIdx(idx: number): void;
+declare function removeNavItem(idx: number): void;
+/**
+ * ## TopNav
+ * Access and updaters for the top nav list
+ */
+export declare function useTopNav(): {
+    topNavItems: {
+        readonly [x: number]: {
+            readonly label: string;
+            readonly icon: import("@scalar/components").Icon;
+            readonly path: string;
+        };
+        readonly length: number;
+        readonly toString: () => string;
+        readonly toLocaleString: {
+            (): string;
+            (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+        };
+        readonly pop: () => {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        } | undefined;
+        readonly push: (...items: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => number;
+        readonly concat: {
+            (...items: ConcatArray<{
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }>[]): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[];
+            (...items: ({
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            } | ConcatArray<{
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }>)[]): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[];
+        };
+        readonly join: (separator?: string) => string;
+        readonly reverse: () => {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[];
+        readonly shift: () => {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        } | undefined;
+        readonly slice: (start?: number, end?: number) => {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[];
+        readonly sort: (compareFn?: ((a: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, b: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }) => number) | undefined) => import("vue").Reactive<Route[]>;
+        readonly splice: {
+            (start: number, deleteCount?: number): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[];
+            (start: number, deleteCount: number, ...items: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[];
+        };
+        readonly unshift: (...items: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => number;
+        readonly indexOf: (searchElement: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, fromIndex?: number) => number;
+        readonly lastIndexOf: (searchElement: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, fromIndex?: number) => number;
+        readonly every: {
+            <S extends {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }>(predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => value is S, thisArg?: any): this is S[];
+            (predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => unknown, thisArg?: any): boolean;
+        };
+        readonly some: (predicate: (value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, index: number, array: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => unknown, thisArg?: any) => boolean;
+        readonly forEach: (callbackfn: (value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, index: number, array: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => void, thisArg?: any) => void;
+        readonly map: <U>(callbackfn: (value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, index: number, array: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => U, thisArg?: any) => U[];
+        readonly filter: {
+            <S extends {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }>(predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => value is S, thisArg?: any): S[];
+            (predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => unknown, thisArg?: any): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[];
+        };
+        readonly reduce: {
+            (callbackfn: (previousValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            };
+            (callbackfn: (previousValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, initialValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            };
+            <U>(callbackfn: (previousValue: U, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => U, initialValue: U): U;
+        };
+        readonly reduceRight: {
+            (callbackfn: (previousValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            };
+            (callbackfn: (previousValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, initialValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            };
+            <U>(callbackfn: (previousValue: U, currentValue: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, currentIndex: number, array: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => U, initialValue: U): U;
+        };
+        readonly find: {
+            <S extends {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }>(predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, obj: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => value is S, thisArg?: any): S | undefined;
+            (predicate: (value: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }, index: number, obj: {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            }[]) => unknown, thisArg?: any): {
+                label: string;
+                icon: import("@scalar/components").Icon;
+                path: string;
+            } | undefined;
+        };
+        readonly findIndex: (predicate: (value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, index: number, obj: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => unknown, thisArg?: any) => number;
+        readonly fill: (value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, start?: number, end?: number) => import("vue").Reactive<Route[]>;
+        readonly copyWithin: (target: number, start: number, end?: number) => import("vue").Reactive<Route[]>;
+        readonly entries: () => IterableIterator<[number, {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }]>;
+        readonly keys: () => IterableIterator<number>;
+        readonly values: () => IterableIterator<{
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }>;
+        readonly includes: (searchElement: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, fromIndex?: number) => boolean;
+        readonly flatMap: <U, This = undefined>(callback: (this: This, value: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }, index: number, array: {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[];
+        readonly flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
+        readonly at: (index: number) => {
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        } | undefined;
+        readonly [Symbol.iterator]: () => IterableIterator<{
+            label: string;
+            icon: import("@scalar/components").Icon;
+            path: string;
+        }>;
+        readonly [Symbol.unscopables]: {
+            readonly [x: number]: boolean | undefined;
+            readonly length?: boolean | undefined;
+            readonly toString?: boolean | undefined;
+            readonly toLocaleString?: boolean | undefined;
+            readonly pop?: boolean | undefined;
+            readonly push?: boolean | undefined;
+            readonly concat?: boolean | undefined;
+            readonly join?: boolean | undefined;
+            readonly reverse?: boolean | undefined;
+            readonly shift?: boolean | undefined;
+            readonly slice?: boolean | undefined;
+            readonly sort?: boolean | undefined;
+            readonly splice?: boolean | undefined;
+            readonly unshift?: boolean | undefined;
+            readonly indexOf?: boolean | undefined;
+            readonly lastIndexOf?: boolean | undefined;
+            readonly every?: boolean | undefined;
+            readonly some?: boolean | undefined;
+            readonly forEach?: boolean | undefined;
+            readonly map?: boolean | undefined;
+            readonly filter?: boolean | undefined;
+            readonly reduce?: boolean | undefined;
+            readonly reduceRight?: boolean | undefined;
+            readonly find?: boolean | undefined;
+            readonly findIndex?: boolean | undefined;
+            readonly fill?: boolean | undefined;
+            readonly copyWithin?: boolean | undefined;
+            readonly entries?: boolean | undefined;
+            readonly keys?: boolean | undefined;
+            readonly values?: boolean | undefined;
+            readonly includes?: boolean | undefined;
+            readonly flatMap?: boolean | undefined;
+            readonly flat?: boolean | undefined;
+            readonly at?: boolean | undefined;
+            readonly [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    };
+    activeNavItemIdx: Readonly<import("vue").Ref<number>>;
+    addNavItem: typeof addNavItem;
+    setNavItemIdx: typeof setNavItemIdx;
+    removeNavItem: typeof removeNavItem;
+};
+export {};
+//# sourceMappingURL=topNav.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"topNav.d.ts","sourceRoot":"","sources":["../../src/store/topNav.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AAgDhD;;;GAGG;AACH,iBAAS,UAAU,SAIlB;AAED,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,QAGjC;AAWD,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,QAOjC;AAED;;;GAGG;AACH,wBAAgB,SAAS;;;;;;;;;;;mDASyoC,KAAM,mBAAmB,GAAE,KAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EADvtC"}

package/dist/store/topNav.js

@@ -0,0 +1,52 @@
+import { ROUTES as c } from "../constants.js";
+import { router as n } from "../router.js";
+import { reactive as v, ref as p, watch as m, readonly as o } from "vue";
+import { useWorkspace as s } from "./workspace.js";
+const { activeRequest: h } = s(), t = v([{ label: "", path: "", icon: "Add" }]), a = p(0);
+function r() {
+  var u;
+  const e = c.find((i) => n.currentRoute.value.path.startsWith(i.path));
+  e && ((e == null ? void 0 : e.label) === "Requests" ? t[a.value] = {
+    label: ((u = h.value) == null ? void 0 : u.summary) || "",
+    path: n.currentRoute.value.path,
+    icon: e.icon
+  } : t[a.value] = {
+    label: (e == null ? void 0 : e.label) || "",
+    path: n.currentRoute.value.path,
+    icon: e.icon
+  });
+}
+function l() {
+  n.push(t[a.value].path);
+}
+function d() {
+  t.push({ label: "", path: "", icon: "Add" }), a.value = t.length - 1, r();
+}
+function f(e) {
+  a.value = e, l();
+}
+m(
+  () => n.currentRoute.value.path,
+  () => {
+    r();
+  },
+  { immediate: !0 }
+);
+function I(e) {
+  t.splice(e, 1), a.value = Math.min(
+    a.value,
+    t.length - 1
+  ), l();
+}
+function A() {
+  return {
+    topNavItems: o(t),
+    activeNavItemIdx: o(a),
+    addNavItem: d,
+    setNavItemIdx: f,
+    removeNavItem: I
+  };
+}
+export {
+  A as useTopNav
+};