@scalar/api-reference 1.38.1 → 1.39.0

package/dist/helpers/lazy-bus.js

@@ -0,0 +1,161 @@
+import { watchDebounced } from "@vueuse/core";
+import { nanoid } from "nanoid";
+import { computed, ref, reactive, onBeforeUnmount, nextTick } from "vue";
+import { getSchemaParamsFromId } from "./id-routing.js";
+const priorityQueue = reactive(/* @__PURE__ */ new Set());
+const pendingQueue = reactive(/* @__PURE__ */ new Set());
+const readyQueue = reactive(/* @__PURE__ */ new Set());
+const isRunning = ref(false);
+const firstLazyLoadComplete = ref(false);
+const intersectionBlockers = reactive(/* @__PURE__ */ new Set());
+const onRenderComplete = /* @__PURE__ */ new Set();
+const addLazyCompleteCallback = (callback) => {
+  if (callback) {
+    onRenderComplete.add(callback);
+  }
+};
+const blockIntersection = () => {
+  const blockId = nanoid();
+  intersectionBlockers.add(blockId);
+  return () => setTimeout(() => intersectionBlockers.delete(blockId), 100);
+};
+const intersectionEnabled = computed(() => intersectionBlockers.size === 0);
+const runLazyBus = () => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const unblock = blockIntersection();
+  const executeRender = async () => {
+    if (pendingQueue.size > 0 || priorityQueue.size > 0) {
+      isRunning.value = true;
+      for (const id of pendingQueue.values()) {
+        readyQueue.add(id);
+        pendingQueue.delete(id);
+        priorityQueue.delete(id);
+      }
+      for (const id of priorityQueue.values()) {
+        readyQueue.add(id);
+        priorityQueue.delete(id);
+        pendingQueue.delete(id);
+      }
+    }
+    await nextTick();
+    onRenderComplete.forEach((fn) => fn());
+    onRenderComplete.clear();
+    unblock();
+    isRunning.value = false;
+    firstLazyLoadComplete.value = true;
+  };
+  if (window.requestIdleCallback) {
+    window.requestIdleCallback(executeRender, { timeout: 1500 });
+  } else {
+    nextTick(executeRender);
+  }
+};
+watchDebounced(
+  [() => pendingQueue.size, () => priorityQueue.size, () => isRunning.value],
+  () => {
+    if ((pendingQueue.size > 0 || priorityQueue.size > 0) && !isRunning.value) {
+      runLazyBus();
+    }
+  },
+  { debounce: 300, maxWait: 1500 }
+);
+const addToPendingQueue = (id) => {
+  if (!!id && !readyQueue.has(id) && !priorityQueue.has(id)) {
+    pendingQueue.add(id);
+  }
+};
+const addToPriorityQueue = (id) => {
+  if (id && !readyQueue.has(id)) {
+    priorityQueue.add(id);
+  }
+};
+const resetLazyElement = (id) => {
+  priorityQueue.delete(id);
+  pendingQueue.delete(id);
+  readyQueue.delete(id);
+};
+function useLazyBus(id) {
+  addToPendingQueue(id);
+  onBeforeUnmount(() => {
+    resetLazyElement(id);
+  });
+  return {
+    isReady: computed(() => typeof window === "undefined" || priorityQueue.has(id) || readyQueue.has(id))
+  };
+}
+const scrollToLazy = (id, setExpanded, getEntryById) => {
+  const item = getEntryById(id);
+  const isLazy = !readyQueue.has(id) || item?.children?.some((child) => !readyQueue.has(child.id));
+  const unfreeze = isLazy ? freeze(id) : void 0;
+  addLazyCompleteCallback(unfreeze);
+  const unblock = blockIntersection();
+  const { rawId } = getSchemaParamsFromId(id);
+  addToPriorityQueue(id);
+  addToPriorityQueue(rawId);
+  if (item?.children) {
+    item.children.slice(0, 2).forEach((child) => {
+      addToPriorityQueue(child.id);
+    });
+  }
+  if (item?.parent) {
+    const parent = getEntryById(item.parent.id);
+    const elementIdx = parent?.children?.findIndex((child) => child.id === id);
+    if (elementIdx !== void 0 && elementIdx >= 0) {
+      parent?.children?.slice(elementIdx, elementIdx + 2).forEach((child) => {
+        addToPriorityQueue(child.id);
+      });
+    }
+  }
+  tryScroll(id, Date.now() + 1e3, unblock, unfreeze);
+  setExpanded(rawId, true);
+  const addParents = (currentId) => {
+    const parent = getEntryById(currentId)?.parent;
+    if (parent) {
+      addToPriorityQueue(parent.id);
+      setExpanded(parent.id, true);
+      addParents(parent.id);
+    }
+  };
+  addParents(rawId);
+};
+const tryScroll = (id, stopTime, onComplete, onFailure) => {
+  const element = document.getElementById(id);
+  if (element) {
+    element.scrollIntoView({
+      block: "start"
+    });
+    onComplete();
+  } else if (Date.now() < stopTime) {
+    requestAnimationFrame(() => tryScroll(id, stopTime, onComplete));
+  } else {
+    onComplete();
+    onFailure?.();
+  }
+};
+const freeze = (id) => {
+  let stop = false;
+  const runFrame = (stopAfterFrame) => {
+    const element = document.getElementById(id);
+    if (element) {
+      element.scrollIntoView({
+        block: "start"
+      });
+    }
+    if (!stopAfterFrame) {
+      requestAnimationFrame(() => runFrame(stop));
+    }
+  };
+  runFrame(false);
+  return () => {
+    stop = true;
+  };
+};
+export {
+  firstLazyLoadComplete,
+  freeze,
+  intersectionEnabled,
+  scrollToLazy,
+  useLazyBus
+};

package/dist/helpers/map-config-to-client-store.d.ts

@@ -0,0 +1,72 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+import type { ApiReferenceConfigurationRaw, OpenAPIV3_1 } from '@scalar/types';
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+import type { SecurityRequirementObject } from '@scalar/workspace-store/schemas/v3.1/strict/security-requirement';
+import type { SecuritySchemeObject } from '@scalar/workspace-store/schemas/v3.1/strict/security-scheme';
+import { type MaybeRefOrGetter } from '@vueuse/core';
+import { type Ref } from 'vue';
+/**
+ * Temporary state mapping factory to handle syncing the client store with the workspace store.
+ */
+export declare function mapConfigToClientStore({ config, workspaceStore, el, root, dereferencedDocument, documentUrl, }: {
+    /** Element the client will be mounted to */
+    el: Ref<HTMLElement | null>;
+    /** Root element used to capture custom events on */
+    root: Ref<HTMLElement | null>;
+    /** Configuration object for API client */
+    config: MaybeRefOrGetter<ApiReferenceConfigurationRaw>;
+    /** Instantiated client store */
+    workspaceStore: WorkspaceStore;
+    dereferencedDocument: MaybeRefOrGetter<OpenAPIV3_1.Document | null>;
+    /** Document URL */
+    documentUrl: MaybeRefOrGetter<string | undefined>;
+}): {
+    activeServer: import("vue").ComputedRef<{
+        url: string;
+        uid: string & import("zod").$brand<"server">;
+        description?: string | undefined;
+        variables?: Record<string, {
+            enum?: string[] | undefined;
+            default?: string | undefined;
+            description?: string | undefined;
+            value?: string | undefined;
+        }> | undefined;
+    } | undefined>;
+    activeEnvVariables: import("vue").ComputedRef<import("@scalar/api-client/store").EnvVariable[]>;
+    activeEnvironment: import("vue").ComputedRef<{
+        uid: string & import("zod").$brand<"environment">;
+        name: string;
+        color: string;
+        value: string;
+        isDefault?: boolean | undefined;
+    }>;
+    activeWorkspace: import("vue").ComputedRef<{
+        uid: string & import("zod").$brand<"workspace">;
+        name: string;
+        description: string;
+        collections: (string & import("zod").$brand<"collection">)[];
+        environments: Record<string, string>;
+        activeEnvironmentId: string;
+        cookies: (string & import("zod").$brand<"cookie">)[];
+        themeId: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "laserwave" | "none";
+        selectedHttpClient: {
+            targetKey: string;
+            clientKey: string;
+        };
+        hotKeyConfig?: {
+            modifiers: ("default" | "Meta" | "Control" | "Shift" | "Alt")[];
+            hotKeys?: Partial<Record<"" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "0" | "Space" | "Backspace" | "Tab" | "Enter" | "Escape" | "ArrowDown" | "ArrowLeft" | "ArrowRight" | "ArrowUp" | "End" | "Home" | "PageDown" | "PageUp" | "Delete" | "*" | "+" | "-" | "." | "/" | "F1" | "F2" | "F3" | "F4" | "F5" | "F6" | "F7" | "F8" | "F9" | "F10" | "F11" | "F12" | ";" | "=" | "," | "`" | "[" | "\\" | "]" | "4" | "1" | "2" | "3" | "5" | "6" | "7" | "8" | "9", {
+                event: "addTopNav" | "closeModal" | "closeTopNav" | "createNew" | "executeRequest" | "focusAddressBar" | "focusRequestSearch" | "jumpToLastTab" | "jumpToTab" | "navigateSearchResultsDown" | "navigateSearchResultsUp" | "navigateTopNavLeft" | "navigateTopNavRight" | "openCommandPalette" | "selectSearchResult" | "toggleSidebar";
+                modifiers?: ("default" | "Meta" | "Control" | "Shift" | "Alt")[] | undefined;
+            }>> | undefined;
+        } | undefined;
+        proxyUrl?: string | undefined;
+    } | undefined>;
+    getSecuritySchemes: SecuritySchemeGetter;
+    openClient: (payload: {
+        method: HttpMethod;
+        path: string;
+    }) => void | undefined;
+};
+export type SecuritySchemeGetter = (operationSecurity: SecurityRequirementObject[] | undefined, documentSecurity: SecurityRequirementObject[] | undefined) => SecuritySchemeObject[];
+//# sourceMappingURL=map-config-to-client-store.d.ts.map

package/dist/helpers/map-config-to-client-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-config-to-client-store.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-to-client-store.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,4BAA4B,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAEpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kEAAkE,CAAA;AACjH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAA;AACvG,OAAO,EAAE,KAAK,gBAAgB,EAAkB,MAAM,cAAc,CAAA;AAEpE,OAAO,EAAE,KAAK,GAAG,EAA4C,MAAM,KAAK,CAAA;AAKxE;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,cAAc,EACd,EAAE,EACF,IAAI,EACJ,oBAAoB,EACpB,WAAW,GACZ,EAAE;IACD,4CAA4C;IAC5C,EAAE,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAC3B,oDAAoD;IACpD,IAAI,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAC7B,0CAA0C;IAC1C,MAAM,EAAE,gBAAgB,CAAC,4BAA4B,CAAC,CAAA;IACtD,gCAAgC;IAChC,cAAc,EAAE,cAAc,CAAA;IAC9B,oBAAoB,EAAE,gBAAgB,CAAC,WAAW,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IACnE,mBAAmB;IACnB,WAAW,EAAE,gBAAgB,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAClD;;;;;;gBAuMk7K,CAAC;mBAA2C,CAAC;uBAA6C,CAAC;iBAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA5rC,CAAC;;yBAAg6B,CAAC;;;;;;0BARlwK;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;EAE7D;AAED,MAAM,MAAM,oBAAoB,GAAG,CACjC,iBAAiB,EAAE,yBAAyB,EAAE,GAAG,SAAS,EAC1D,gBAAgB,EAAE,yBAAyB,EAAE,GAAG,SAAS,KACtD,oBAAoB,EAAE,CAAA"}

package/dist/helpers/map-config-to-client-store.js

@@ -0,0 +1,146 @@
+import { createApiClientModal } from "@scalar/api-client/layouts/Modal";
+import { createWorkspaceStore, createActiveEntitiesStore, WORKSPACE_SYMBOL, ACTIVE_ENTITIES_SYMBOL } from "@scalar/api-client/store";
+import { mutateSecuritySchemeDiff } from "@scalar/api-client/views/Request/libs";
+import { filterSecurityRequirements } from "@scalar/api-client/views/Request/RequestSection";
+import { getServersFromDocument } from "@scalar/oas-utils/helpers";
+import { emitCustomEvent } from "@scalar/workspace-store/events";
+import { watchDebounced } from "@vueuse/core";
+import microdiff from "microdiff";
+import { toValue, provide, watch, toRaw, computed } from "vue";
+import { convertSecurityScheme } from "./convert-security-scheme.js";
+import { useLegacyStoreEvents } from "../hooks/use-legacy-store-events.js";
+function mapConfigToClientStore({
+  config,
+  workspaceStore,
+  el,
+  root,
+  dereferencedDocument,
+  documentUrl
+}) {
+  const store = createWorkspaceStore({
+    useLocalStorage: false,
+    proxyUrl: toValue(config).proxyUrl,
+    theme: toValue(config).theme,
+    showSidebar: toValue(config).showSidebar,
+    hideClientButton: toValue(config).hideClientButton,
+    _integration: toValue(config)._integration
+  });
+  let client = null;
+  const activeEntities = createActiveEntitiesStore(store);
+  provide(WORKSPACE_SYMBOL, store);
+  provide(ACTIVE_ENTITIES_SYMBOL, activeEntities);
+  useLegacyStoreEvents(workspaceStore, store, activeEntities, root);
+  watch(
+    el,
+    () => {
+      console.info(`[CLIENT]: Client element changed. ${el.value ? "Mounting client..." : "Unmounting client..."}`);
+      if (!el.value) {
+        client?.app?.unmount();
+        return;
+      }
+      const clientConfig = toValue(config);
+      const mount = createApiClientModal({
+        el: el.value,
+        configuration: {
+          ...clientConfig,
+          plugins: typeof clientConfig.onBeforeRequest === "function" ? [
+            () => ({
+              name: "on-before-request",
+              hooks: {
+                onBeforeRequest: clientConfig.onBeforeRequest
+              }
+            })
+          ] : []
+        },
+        store
+      });
+      client = mount.client;
+    },
+    {
+      immediate: true
+    }
+  );
+  watchDebounced(
+    () => toValue(config),
+    (newConfig, oldConfig) => {
+      if (!oldConfig || !activeEntities.activeCollection.value) {
+        return;
+      }
+      microdiff(oldConfig, newConfig).forEach((d) => {
+        if (d.path[0] === "authentication") {
+          mutateSecuritySchemeDiff(d, activeEntities, store);
+        }
+      });
+    },
+    { deep: true, debounce: 300 }
+  );
+  watch(
+    [() => toValue(config).servers, () => toValue(dereferencedDocument)?.servers, () => toValue(config).baseServerURL],
+    ([newServers], [oldServers]) => {
+      if (newServers || oldServers) {
+        const servers = getServersFromDocument(newServers ?? toValue(dereferencedDocument)?.servers, {
+          baseServerURL: toValue(config).baseServerURL
+        });
+        emitCustomEvent(el.value, "scalar-replace-servers", {
+          servers,
+          options: {
+            disableOldStoreUpdate: true
+          }
+        });
+      }
+    }
+  );
+  watchDebounced(
+    () => toValue(dereferencedDocument),
+    (newDocument, oldDocument) => {
+      if (!newDocument) {
+        return;
+      }
+      const diff = microdiff(newDocument, oldDocument || {});
+      if (!diff?.length) {
+        return;
+      }
+      if (activeEntities.activeCollection.value) {
+        client?.resetStore();
+      }
+      return store.importSpecFile(void 0, "default", {
+        dereferencedDocument: toRaw(newDocument),
+        shouldLoad: true,
+        documentUrl: toValue(documentUrl),
+        useCollectionSecurity: true,
+        ...toValue(config)
+      });
+    }
+  );
+  const { activeCollection, activeEnvVariables, activeEnvironment, activeWorkspace } = activeEntities;
+  const activeServer = computed(() => {
+    if (!activeCollection.value) {
+      return void 0;
+    }
+    if (activeCollection.value.selectedServerUid) {
+      const server = store.servers[activeCollection.value.selectedServerUid];
+      if (server) {
+        return server;
+      }
+    }
+    return store.servers[activeCollection.value.servers[0] ?? ""];
+  });
+  const getSecuritySchemes = (operationSecurity, documentSecurity) => {
+    return filterSecurityRequirements(
+      operationSecurity || documentSecurity || [],
+      activeCollection.value?.selectedSecuritySchemeUids || [],
+      store.securitySchemes
+    ).map(convertSecurityScheme);
+  };
+  return {
+    activeServer,
+    activeEnvVariables,
+    activeEnvironment,
+    activeWorkspace,
+    getSecuritySchemes,
+    openClient: (payload) => client?.open(payload)
+  };
+}
+export {
+  mapConfigToClientStore
+};

package/dist/helpers/map-config-to-workspace-store.d.ts

@@ -0,0 +1,9 @@
+import type { ApiReferenceConfigurationRaw } from '@scalar/types';
+import type { WorkspaceStore } from '@scalar/workspace-store/client';
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+export declare const mapConfigToWorkspaceStore: ({ config, store, isDarkMode, }: {
+    config: MaybeRefOrGetter<ApiReferenceConfigurationRaw>;
+    store: WorkspaceStore;
+    isDarkMode: Ref<boolean>;
+}) => void;
+//# sourceMappingURL=map-config-to-workspace-store.d.ts.map

package/dist/helpers/map-config-to-workspace-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-config-to-workspace-store.d.ts","sourceRoot":"","sources":["../../src/helpers/map-config-to-workspace-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAGpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,GAAG,EAA2C,MAAM,KAAK,CAAA;AAE9F,eAAO,MAAM,yBAAyB,GAAI,gCAIvC;IACD,MAAM,EAAE,gBAAgB,CAAC,4BAA4B,CAAC,CAAA;IACtD,KAAK,EAAE,cAAc,CAAA;IACrB,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CACzB,SA4CA,CAAA"}

package/dist/helpers/map-config-to-workspace-store.js

@@ -0,0 +1,47 @@
+import { isClient } from "@scalar/api-client/v2/blocks/operation-code-sample";
+import { safeLocalStorage, REFERENCE_LS_KEYS } from "@scalar/helpers/object/local-storage";
+import { useSeoMeta } from "@unhead/vue";
+import { useFavicon } from "@vueuse/core";
+import { onBeforeMount, watch, toValue, computed } from "vue";
+const mapConfigToWorkspaceStore = ({
+  config,
+  store,
+  isDarkMode
+}) => {
+  onBeforeMount(() => {
+    const storedClient = safeLocalStorage().getItem(REFERENCE_LS_KEYS.SELECTED_CLIENT);
+    if (isClient(storedClient) && !store.workspace["x-scalar-default-client"]) {
+      store.update("x-scalar-default-client", storedClient);
+    }
+  });
+  watch(
+    () => toValue(config).defaultHttpClient,
+    (newValue) => {
+      if (newValue) {
+        const { targetKey, clientKey } = newValue;
+        const clientId = `${targetKey}/${clientKey}`;
+        if (isClient(clientId)) {
+          store.update("x-scalar-default-client", clientId);
+        }
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => toValue(config).darkMode,
+    (isDark) => store.update("x-scalar-dark-mode", !!isDark)
+  );
+  watch(
+    () => isDarkMode.value,
+    (newValue) => store.update("x-scalar-dark-mode", newValue),
+    { immediate: true }
+  );
+  if (toValue(config).metaData) {
+    useSeoMeta(toValue(config).metaData);
+  }
+  const favicon = computed(() => toValue(config).favicon);
+  useFavicon(favicon);
+};
+export {
+  mapConfigToWorkspaceStore
+};

package/dist/helpers/map-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-configuration.d.ts","sourceRoot":"","sources":["../../src/helpers/map-configuration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAA;AAG9D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,CAAC,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgD1E,CAAA"}

package/dist/helpers/map-configuration.js

@@ -0,0 +1,52 @@
+const mapConfiguration = (config) => {
+  return {
+    "x-scalar-reference-config": {
+      title: config.title,
+      slug: config.slug,
+      features: {
+        // Feature toggles for UI elements and behaviors
+        showModels: !config.hideModels,
+        expandAllTagSections: config.defaultOpenAllTags,
+        persistAuthenticationState: config.persistAuth,
+        showDarkModeToggle: !config.hideDarkModeToggle,
+        showDownload: !config.hideDownloadButton,
+        showSearch: !config.hideSearch,
+        showSidebar: config.showSidebar,
+        showTestRequestButton: !config.hideTestRequestButton
+      },
+      appearance: {
+        // Appearance-related configuration
+        css: config.customCss,
+        favicon: config.favicon,
+        forceColorMode: config.forceDarkModeState,
+        initialColorMode: config.darkMode ? "dark" : void 0,
+        layout: config.layout,
+        loadDefaultFonts: config.withDefaultFonts,
+        theme: config.theme
+      },
+      routing: {
+        // Routing configuration
+        basePath: config.pathRouting?.basePath
+      },
+      settings: {
+        // Miscellaneous settings
+        proxyUrl: config.proxyUrl,
+        searchKey: config.searchHotKey,
+        baseServerUrl: config.baseServerURL,
+        servers: config.servers
+      },
+      meta: config.metaData,
+      // In memory configuration
+      tagSort: config.tagsSorter,
+      operationsSorter: config.operationsSorter,
+      generateHeadingSlug: config.generateHeadingSlug,
+      generateModelSlug: config.generateModelSlug,
+      generateOperationSlug: config.generateOperationSlug,
+      generateTagSlug: config.generateTagSlug,
+      generateWebhookSlug: config.generateWebhookSlug
+    }
+  };
+};
+export {
+  mapConfiguration
+};

package/dist/helpers/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/helpers/markdown.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAWnD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAMhE;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAEjD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,UAAU,OAAO,EAAE,KAAG,aAQ3D,CAAA"}

package/dist/helpers/normalize-configurations.d.ts

@@ -0,0 +1,42 @@
+import { type AnyApiReferenceConfiguration, type ApiReferenceConfigurationRaw, type ApiReferenceConfigurationWithSource } from '@scalar/types';
+import GithubSlugger from 'github-slugger';
+/** Processed API Reference Configuration
+ *
+ * Creates the required title and slug for the API Reference.
+ * Separate the source into a dedicated object
+ * Returns the raw configuration to pass to components
+ */
+export type NormalizedConfiguration = {
+    title: string;
+    slug: string;
+    config: ApiReferenceConfigurationRaw;
+    default: boolean;
+    source: {
+        url: string;
+        content?: never;
+    } | {
+        content: Record<string, unknown>;
+        url?: never;
+    };
+};
+type NormalizedConfigurations = Record<string, NormalizedConfiguration>;
+type ConfigWithRequiredSource = Omit<ApiReferenceConfigurationWithSource, 'url' | 'content'> & ({
+    url: string;
+    content?: never;
+} | {
+    content: Record<string, unknown>;
+    url?: never;
+});
+/**
+ * Take any configuration and return a flat array of configurations.
+ */
+export declare const normalizeConfigurations: (configuration: AnyApiReferenceConfiguration | undefined) => NormalizedConfigurations;
+/** Normalize content into a JS object or return null if it is falsey */
+export declare const normalizeContent: (content: string | Record<string, unknown> | (() => string | Record<string, unknown>)) => Record<string, unknown> | null;
+/** Process a single spec configuration so that it has a title and a slug */
+export declare const addSlugAndTitle: (source: ConfigWithRequiredSource, index: number | undefined, slugger: GithubSlugger) => ConfigWithRequiredSource & {
+    slug: string;
+    title: string;
+};
+export {};
+//# sourceMappingURL=normalize-configurations.d.ts.map

package/dist/helpers/normalize-configurations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-configurations.d.ts","sourceRoot":"","sources":["../../src/helpers/normalize-configurations.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,mCAAmC,EAGzC,MAAM,eAAe,CAAA;AACtB,OAAO,aAAa,MAAM,gBAAgB,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,4BAA4B,CAAA;IACpC,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,GAAG,CAAC,EAAE,KAAK,CAAA;KAAE,CAAA;CAC7F,CAAA;AAED,KAAK,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;AAEvE,KAAK,wBAAwB,GAAG,IAAI,CAAC,mCAAmC,EAAE,KAAK,GAAG,SAAS,CAAC,GAC1F,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAExF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,eAAe,4BAA4B,GAAG,SAAS,KACtD,wBAmDF,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KACnF,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAc5B,CAAA;AAED,4EAA4E;AAC5E,eAAO,MAAM,eAAe,GAC1B,QAAQ,wBAAwB,EAChC,yBAAS,EACT,SAAS,aAAa,KACrB,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAyB1D,CAAA"}

package/dist/helpers/normalize-configurations.js

@@ -0,0 +1,69 @@
+import { parseJsonOrYaml } from "@scalar/oas-utils/helpers";
+import { isConfigurationWithSources, apiReferenceConfigurationWithSourceSchema } from "@scalar/types";
+import GitHubSlugger from "github-slugger";
+const normalizeConfigurations = (configuration) => {
+  const slugger = new GitHubSlugger();
+  const normalized = {};
+  if (!configuration) {
+    return normalized;
+  }
+  const configList = Array.isArray(configuration) ? configuration : [configuration];
+  configList.flatMap((c) => {
+    if (isConfigurationWithSources(c)) {
+      const { sources: configSources, ...rest } = c;
+      return configSources?.map((source) => ({ ...rest, ...source })) ?? [];
+    }
+    return [c];
+  }).map((source) => {
+    const validated = apiReferenceConfigurationWithSourceSchema.safeParse(source);
+    return validated.success ? validated.data : null;
+  }).filter((c) => !!c && (!!c.url || !!c.content)).map((source, index) => addSlugAndTitle(source, index, slugger)).forEach((c) => {
+    const { url, content, ...config } = c;
+    normalized[c.slug] = {
+      config,
+      title: c.title,
+      slug: c.slug,
+      default: !!c?.default,
+      source: content ? { content: normalizeContent(content) ?? {} } : { url }
+    };
+  });
+  return normalized;
+};
+const normalizeContent = (content) => {
+  if (!content) {
+    return null;
+  }
+  if (typeof content === "function") {
+    return normalizeContent(content());
+  }
+  if (typeof content === "string") {
+    return parseJsonOrYaml(content);
+  }
+  return content;
+};
+const addSlugAndTitle = (source, index = 0, slugger) => {
+  if (source.title) {
+    return {
+      ...source,
+      slug: source.slug || slugger.slug(source.title),
+      title: source.title
+    };
+  }
+  if (source.slug) {
+    return {
+      ...source,
+      slug: slugger.slug(source.slug),
+      title: source.slug
+    };
+  }
+  return {
+    ...source,
+    slug: `api-${index + 1}`,
+    title: `API #${index + 1}`
+  };
+};
+export {
+  addSlugAndTitle,
+  normalizeConfigurations,
+  normalizeContent
+};

package/dist/helpers/openapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.d.ts","sourceRoot":"","sources":["../../src/helpers/openapi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGjE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAEpH;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,YAAY,GAAG,MAAM,CAejF;AA+BD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,EAAE,GAAG,OAAO,CAYjF;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,oBAW3E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAiBjF,OAAO,CAAC,QAAQ,CACvB;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,eAAe,EAAE,CAAA;IACvB,KAAK,EAAE,eAAe,EAAE,CAAA;IACxB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,IAAI,EAAE,eAAe,EAAE,CAAA;IACvB,QAAQ,EAAE,eAAe,EAAE,CAAA;CAC5B,CAAA;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,gBA2D5D"}