@scalar/helpers 0.4.1 → 0.4.2

package/dist/general/debounce.js

@@ -1,67 +1,87 @@
-const debounce = (options = {}) => {
-  const { delay = 328, maxWait } = options;
-  const timeouts = /* @__PURE__ */ new Map();
-  const maxWaitTimeouts = /* @__PURE__ */ new Map();
-  const latestFunctions = /* @__PURE__ */ new Map();
-  const cleanup = () => {
-    timeouts.forEach(clearTimeout);
-    maxWaitTimeouts.forEach(clearTimeout);
-    timeouts.clear();
-    maxWaitTimeouts.clear();
-    latestFunctions.clear();
-  };
-  const executeAndCleanup = (key) => {
-    const fn = latestFunctions.get(key);
-    const timeout = timeouts.get(key);
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
-      timeouts.delete(key);
-    }
-    const maxWaitTimeout = maxWaitTimeouts.get(key);
-    if (maxWaitTimeout !== void 0) {
-      clearTimeout(maxWaitTimeout);
-      maxWaitTimeouts.delete(key);
-    }
-    latestFunctions.delete(key);
-    if (fn !== void 0) {
-      try {
-        fn();
-      } catch {
-      }
-    }
-  };
-  const execute = (key, fn) => {
-    latestFunctions.set(key, fn);
-    const existingTimeout = timeouts.get(key);
-    if (existingTimeout !== void 0) {
-      clearTimeout(existingTimeout);
-    }
-    timeouts.set(
-      key,
-      setTimeout(() => executeAndCleanup(key), delay)
-    );
-    if (maxWait !== void 0 && !maxWaitTimeouts.has(key)) {
-      maxWaitTimeouts.set(
-        key,
-        setTimeout(() => executeAndCleanup(key), maxWait)
-      );
-    }
-  };
-  const flush = (key) => {
-    if (!latestFunctions.has(key)) {
-      return;
-    }
-    executeAndCleanup(key);
-  };
-  const flushAll = () => {
-    const keys = [...latestFunctions.keys()];
-    for (const key of keys) {
-      executeAndCleanup(key);
-    }
-  };
-  return { execute, cleanup, flush, flushAll };
+/**
+ * Creates a debounced function executor that delays execution until after a specified time.
+ * Multiple calls with the same key will cancel previous pending executions.
+ *
+ * This is useful for batching rapid updates (like auto-save or API calls) to avoid
+ * unnecessary processing or network requests.
+ *
+ * @param options - Configuration options for delay, maxWait, and key separator
+ * @returns A function that accepts a key array and callback to execute
+ *
+ * @example
+ * const debouncedSave = debounce({ delay: 328 })
+ * debouncedSave.execute(['user', '123'], () => saveUser(user))
+ *
+ * @example
+ * // With maxWait to guarantee execution even with continuous calls
+ * const debouncedSave = debounce({ delay: 328, maxWait: 2000 })
+ * debouncedSave.execute(['user', '123'], () => saveUser(user))
+ */
+export const debounce = (options = {}) => {
+    const { delay = 328, maxWait } = options;
+    const timeouts = new Map();
+    const maxWaitTimeouts = new Map();
+    const latestFunctions = new Map();
+    const cleanup = () => {
+        timeouts.forEach(clearTimeout);
+        maxWaitTimeouts.forEach(clearTimeout);
+        timeouts.clear();
+        maxWaitTimeouts.clear();
+        latestFunctions.clear();
+    };
+    /** Executes the function and cleans up all associated timeouts */
+    const executeAndCleanup = (key) => {
+        // Get the latest function for this key
+        const fn = latestFunctions.get(key);
+        // Clear both timeout types
+        const timeout = timeouts.get(key);
+        if (timeout !== undefined) {
+            clearTimeout(timeout);
+            timeouts.delete(key);
+        }
+        const maxWaitTimeout = maxWaitTimeouts.get(key);
+        if (maxWaitTimeout !== undefined) {
+            clearTimeout(maxWaitTimeout);
+            maxWaitTimeouts.delete(key);
+        }
+        // Clear the latest function reference
+        latestFunctions.delete(key);
+        // Execute the function if it exists
+        if (fn !== undefined) {
+            try {
+                fn();
+            }
+            catch {
+                // Errors are silently caught to prevent the debounce mechanism from breaking
+            }
+        }
+    };
+    const execute = (key, fn) => {
+        // Store the latest function for this key
+        latestFunctions.set(key, fn);
+        // Clear existing debounce timeout
+        const existingTimeout = timeouts.get(key);
+        if (existingTimeout !== undefined) {
+            clearTimeout(existingTimeout);
+        }
+        // Set debounce timeout
+        timeouts.set(key, setTimeout(() => executeAndCleanup(key), delay));
+        // Set maxWait timeout only if configured and this is a new sequence
+        if (maxWait !== undefined && !maxWaitTimeouts.has(key)) {
+            maxWaitTimeouts.set(key, setTimeout(() => executeAndCleanup(key), maxWait));
+        }
+    };
+    const flush = (key) => {
+        if (!latestFunctions.has(key)) {
+            return;
+        }
+        executeAndCleanup(key);
+    };
+    const flushAll = () => {
+        const keys = [...latestFunctions.keys()];
+        for (const key of keys) {
+            executeAndCleanup(key);
+        }
+    };
+    return { execute, cleanup, flush, flushAll };
 };
-export {
-  debounce
-};
-//# sourceMappingURL=debounce.js.map

package/dist/general/extract-config-secrets.js

@@ -1,31 +1,33 @@
-import { objectEntries } from "../object/object-entries.js";
+import { objectEntries } from '../object/object-entries.js';
+/**
+ * Mapping of field names to their corresponding x-scalar-secret extension names.
+ */
 const SECRET_FIELD_MAPPINGS = {
-  clientSecret: "x-scalar-secret-client-secret",
-  password: "x-scalar-secret-password",
-  token: "x-scalar-secret-token",
-  username: "x-scalar-secret-username",
-  value: "x-scalar-secret-token",
-  "x-scalar-client-id": "x-scalar-secret-client-id",
-  "x-scalar-redirect-uri": "x-scalar-secret-redirect-uri"
+    clientSecret: 'x-scalar-secret-client-secret',
+    password: 'x-scalar-secret-password',
+    token: 'x-scalar-secret-token',
+    username: 'x-scalar-secret-username',
+    value: 'x-scalar-secret-token',
+    'x-scalar-client-id': 'x-scalar-secret-client-id',
+    'x-scalar-redirect-uri': 'x-scalar-secret-redirect-uri',
 };
-const extractConfigSecrets = (input) => objectEntries(SECRET_FIELD_MAPPINGS).reduce((result, [field, secretField]) => {
-  const value = input[field];
-  if (value && typeof value === "string") {
-    result[secretField] = value;
-  }
-  return result;
+/**
+ * Extracts secret fields from the config or the old schemes
+ * Maps original field names to their x-scalar-secret extension equivalents.
+ */
+export const extractConfigSecrets = (input) => objectEntries(SECRET_FIELD_MAPPINGS).reduce((result, [field, secretField]) => {
+    const value = input[field];
+    if (value && typeof value === 'string') {
+        result[secretField] = value;
+    }
+    return result;
 }, {});
-const SECRETS_SET = new Set(
-  objectEntries(SECRET_FIELD_MAPPINGS).flatMap(([oldSecret, newSecret]) => [oldSecret, newSecret])
-);
-const removeSecretFields = (input) => objectEntries(input).reduce((result, [key, value]) => {
-  if (!SECRETS_SET.has(key)) {
-    result[key] = value;
-  }
-  return result;
+/** Set of all secret fields */
+const SECRETS_SET = new Set(objectEntries(SECRET_FIELD_MAPPINGS).flatMap(([oldSecret, newSecret]) => [oldSecret, newSecret]));
+/** Removes all secret fields from the input object */
+export const removeSecretFields = (input) => objectEntries(input).reduce((result, [key, value]) => {
+    if (!SECRETS_SET.has(key)) {
+        result[key] = value;
+    }
+    return result;
 }, {});
-export {
-  extractConfigSecrets,
-  removeSecretFields
-};
-//# sourceMappingURL=extract-config-secrets.js.map

package/dist/general/has-modifier.js

@@ -1,9 +1,10 @@
-import { isMacOS } from "./is-mac-os.js";
-const hasModifier = (keydown) => {
-  const modifier = isMacOS() ? "metaKey" : "ctrlKey";
-  return keydown[modifier];
+import { isMacOS } from './is-mac-os.js';
+/**
+ * Checks for the modifier key
+ *
+ * Which is meta on macOs and ctrl on linux/windows
+ */
+export const hasModifier = (keydown) => {
+    const modifier = isMacOS() ? 'metaKey' : 'ctrlKey';
+    return keydown[modifier];
 };
-export {
-  hasModifier
-};
-//# sourceMappingURL=has-modifier.js.map

package/dist/general/is-mac-os.js

@@ -1,24 +1,26 @@
+/**
+ * Checks whether the user is on macOS
+ * Uses the modern navigator.userAgentData API with a fallback to navigator.userAgent
+ */
 const getUserAgentDataPlatform = (nav) => {
-  const userAgentData = Reflect.get(nav, "userAgentData");
-  if (!userAgentData || typeof userAgentData !== "object") {
-    return void 0;
-  }
-  if (!("platform" in userAgentData) || typeof userAgentData.platform !== "string") {
-    return void 0;
-  }
-  return userAgentData.platform;
+    const userAgentData = Reflect.get(nav, 'userAgentData');
+    if (!userAgentData || typeof userAgentData !== 'object') {
+        return undefined;
+    }
+    if (!('platform' in userAgentData) || typeof userAgentData.platform !== 'string') {
+        return undefined;
+    }
+    return userAgentData.platform;
 };
-const isMacOS = () => {
-  if (typeof navigator === "undefined") {
-    return false;
-  }
-  const userAgentDataPlatform = getUserAgentDataPlatform(navigator);
-  if (userAgentDataPlatform) {
-    return userAgentDataPlatform.toLowerCase().includes("mac");
-  }
-  return /Mac/.test(navigator.userAgent);
+export const isMacOS = () => {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+    // Modern approach using navigator.userAgentData
+    const userAgentDataPlatform = getUserAgentDataPlatform(navigator);
+    if (userAgentDataPlatform) {
+        return userAgentDataPlatform.toLowerCase().includes('mac');
+    }
+    // Fallback to userAgent
+    return /Mac/.test(navigator.userAgent);
 };
-export {
-  isMacOS
-};
-//# sourceMappingURL=is-mac-os.js.map

package/dist/http/can-method-have-body.js

@@ -1,6 +1,4 @@
-const BODY_METHODS = ["post", "put", "patch", "delete"];
-const canMethodHaveBody = (method) => BODY_METHODS.includes(method.toLowerCase());
-export {
-  canMethodHaveBody
-};
-//# sourceMappingURL=can-method-have-body.js.map
+/** HTTP Methods which can have a body */
+const BODY_METHODS = ['post', 'put', 'patch', 'delete'];
+/** Makes a check to see if this method CAN have a body */
+export const canMethodHaveBody = (method) => BODY_METHODS.includes(method.toLowerCase());

package/dist/http/http-info.js

@@ -1,63 +1,65 @@
-const REQUEST_METHODS = {
-  get: {
-    short: "GET",
-    colorClass: "text-blue",
-    colorVar: "var(--scalar-color-blue)",
-    backgroundColor: "bg-blue/10"
-  },
-  post: {
-    short: "POST",
-    colorClass: "text-green",
-    colorVar: "var(--scalar-color-green)",
-    backgroundColor: "bg-green/10"
-  },
-  put: {
-    short: "PUT",
-    colorClass: "text-orange",
-    colorVar: "var(--scalar-color-orange)",
-    backgroundColor: "bg-orange/10"
-  },
-  patch: {
-    short: "PATCH",
-    colorClass: "text-yellow",
-    colorVar: "var(--scalar-color-yellow)",
-    backgroundColor: "bg-yellow/10"
-  },
-  delete: {
-    short: "DEL",
-    colorClass: "text-red",
-    colorVar: "var(--scalar-color-red)",
-    backgroundColor: "bg-red/10"
-  },
-  options: {
-    short: "OPTS",
-    colorClass: "text-purple",
-    colorVar: "var(--scalar-color-purple)",
-    backgroundColor: "bg-purple/10"
-  },
-  head: {
-    short: "HEAD",
-    colorClass: "text-c-2",
-    colorVar: "var(--scalar-color-2)",
-    backgroundColor: "bg-c-2/10"
-  },
-  trace: {
-    short: "TRACE",
-    colorClass: "text-c-2",
-    colorVar: "var(--scalar-color-2)",
-    backgroundColor: "bg-c-2/10"
-  }
+/**
+ * HTTP methods in a specific order
+ * Do not change the order
+ */
+export const REQUEST_METHODS = {
+    get: {
+        short: 'GET',
+        colorClass: 'text-blue',
+        colorVar: 'var(--scalar-color-blue)',
+        backgroundColor: 'bg-blue/10',
+    },
+    post: {
+        short: 'POST',
+        colorClass: 'text-green',
+        colorVar: 'var(--scalar-color-green)',
+        backgroundColor: 'bg-green/10',
+    },
+    put: {
+        short: 'PUT',
+        colorClass: 'text-orange',
+        colorVar: 'var(--scalar-color-orange)',
+        backgroundColor: 'bg-orange/10',
+    },
+    patch: {
+        short: 'PATCH',
+        colorClass: 'text-yellow',
+        colorVar: 'var(--scalar-color-yellow)',
+        backgroundColor: 'bg-yellow/10',
+    },
+    delete: {
+        short: 'DEL',
+        colorClass: 'text-red',
+        colorVar: 'var(--scalar-color-red)',
+        backgroundColor: 'bg-red/10',
+    },
+    options: {
+        short: 'OPTS',
+        colorClass: 'text-purple',
+        colorVar: 'var(--scalar-color-purple)',
+        backgroundColor: 'bg-purple/10',
+    },
+    head: {
+        short: 'HEAD',
+        colorClass: 'text-c-2',
+        colorVar: 'var(--scalar-color-2)',
+        backgroundColor: 'bg-c-2/10',
+    },
+    trace: {
+        short: 'TRACE',
+        colorClass: 'text-c-2',
+        colorVar: 'var(--scalar-color-2)',
+        backgroundColor: 'bg-c-2/10',
+    },
 };
-const getHttpMethodInfo = (methodName) => {
-  const normalizedMethod = methodName.trim().toLowerCase();
-  return REQUEST_METHODS[normalizedMethod] ?? {
-    short: normalizedMethod,
-    color: "text-c-2",
-    backgroundColor: "bg-c-2"
-  };
+/**
+ * Accepts an HTTP Method name and returns some properties for the tag
+ */
+export const getHttpMethodInfo = (methodName) => {
+    const normalizedMethod = methodName.trim().toLowerCase();
+    return (REQUEST_METHODS[normalizedMethod] ?? {
+        short: normalizedMethod,
+        color: 'text-c-2',
+        backgroundColor: 'bg-c-2',
+    });
 };
-export {
-  REQUEST_METHODS,
-  getHttpMethodInfo
-};
-//# sourceMappingURL=http-info.js.map

package/dist/http/http-methods.js

@@ -1,7 +1,4 @@
-const HTTP_METHODS = ["delete", "get", "head", "options", "patch", "post", "put", "trace"];
-const httpMethods = Object.freeze(new Set(HTTP_METHODS));
-export {
-  HTTP_METHODS,
-  httpMethods
-};
-//# sourceMappingURL=http-methods.js.map
+/** All OpenAPI HTTP methods */
+export const HTTP_METHODS = ['delete', 'get', 'head', 'options', 'patch', 'post', 'put', 'trace'];
+/** Set of all http methods we support */
+export const httpMethods = Object.freeze(new Set(HTTP_METHODS));