@scalar/helpers 0.2.8 → 0.2.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @scalar/helpers
 
+## 0.2.10
+
+### Patch Changes
+
+- [#7963](https://github.com/scalar/scalar/pull/7963): feat: unify is-object helpers
+
+## 0.2.9
+
+### Patch Changes
+
+- [#7894](https://github.com/scalar/scalar/pull/7894): fix: the import and export of redirect to proxy
+
 ## 0.2.8
 
 ### Patch Changes

package/dist/object/is-object.d.ts

@@ -1,17 +1,19 @@
 /**
- * Returns true if the provided value is a plain object
- * (i.e. not null, not an array, and typeof value is "object").
+ * Returns true if the provided value is a record object
+ * (i.e. not null, not an array, and has an actual object as the prototype).
  *
- * This is a type guard useful for narrowing types in TypeScript.
+ * Differs from the previous isObject in that it returns false for Date,
+ * RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.
  *
  * Examples:
- *   isObject({})                // true
- *   isObject({ a: 1 })          // true
- *   isObject([])                // false (Array)
- *   isObject(null)              // false
- *   isObject(123)               // false
- *   isObject('string')          // false
- *   isObject(new Date())        // true  (note: Date is technically an object)
+ *   isObject({})                  // true
+ *   isObject({ a: 1 })            // true
+ *   isObject([])                  // false (Array)
+ *   isObject(null)                // false
+ *   isObject(123)                 // false
+ *   isObject('string')            // false
+ *   isObject(new Error('test'))   // false
+ *   isObject(new Date())          // false
  *   isObject(Object.create(null)) // true
  */
 export declare const isObject: (value: unknown) => value is Record<string, unknown>;

package/dist/object/is-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-object.d.ts","sourceRoot":"","sources":["../../src/object/is-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAExE,CAAA"}
+{"version":3,"file":"is-object.d.ts","sourceRoot":"","sources":["../../src/object/is-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAOxE,CAAA"}

package/dist/object/is-object.js

@@ -1,5 +1,9 @@
 const isObject = (value) => {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 };
 export {
   isObject

package/dist/object/is-object.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/object/is-object.ts"],
-  "sourcesContent": ["/**\n * Returns true if the provided value is a plain object\n * (i.e. not null, not an array, and typeof value is \"object\").\n *\n * This is a type guard useful for narrowing types in TypeScript.\n *\n * Examples:\n *   isObject({})                // true\n *   isObject({ a: 1 })          // true\n *   isObject([])                // false (Array)\n *   isObject(null)              // false\n *   isObject(123)               // false\n *   isObject('string')          // false\n *   isObject(new Date())        // true  (note: Date is technically an object)\n *   isObject(Object.create(null)) // true\n */\nexport const isObject = (value: unknown): value is Record<string, unknown> => {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"],
-  "mappings": "AAgBO,MAAM,WAAW,CAAC,UAAqD;AAC5E,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;",
+  "sourcesContent": ["/**\n * Returns true if the provided value is a record object\n * (i.e. not null, not an array, and has an actual object as the prototype).\n *\n * Differs from the previous isObject in that it returns false for Date,\n * RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.\n *\n * Examples:\n *   isObject({})                  // true\n *   isObject({ a: 1 })            // true\n *   isObject([])                  // false (Array)\n *   isObject(null)                // false\n *   isObject(123)                 // false\n *   isObject('string')            // false\n *   isObject(new Error('test'))   // false\n *   isObject(new Date())          // false\n *   isObject(Object.create(null)) // true\n */\nexport const isObject = (value: unknown): value is Record<string, unknown> => {\n  if (value === null || typeof value !== 'object') {\n    return false\n  }\n\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n"],
+  "mappings": "AAkBO,MAAM,WAAW,CAAC,UAAqD;AAC5E,MAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,OAAO,eAAe,KAAK;AACzC,SAAO,UAAU,OAAO,aAAa,UAAU;AACjD;",
   "names": []
 }

package/dist/url/redirect-to-proxy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Redirects the request to a proxy server with a given URL. But not for:
+ *
+ * - Relative URLs
+ * - URLs that seem to point to a local IP (except the proxy is on the same domain)
+ * - URLs that don't look like a domain
+ **/
+export declare const redirectToProxy: (proxyUrl?: string, url?: string) => string;
+/**
+ * Returns false for requests to localhost, relative URLs, if no proxy is defined …
+ **/
+export declare const shouldUseProxy: (proxyUrl?: string, url?: string) => url is string;
+//# sourceMappingURL=redirect-to-proxy.d.ts.map

package/dist/url/redirect-to-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect-to-proxy.d.ts","sourceRoot":"","sources":["../../src/url/redirect-to-proxy.ts"],"names":[],"mappings":"AAGA;;;;;;IAMI;AACJ,eAAO,MAAM,eAAe,GAAI,WAAW,MAAM,EAAE,MAAM,MAAM,KAAG,MAkCjE,CAAA;AAED;;IAEI;AACJ,eAAO,MAAM,cAAc,GAAI,WAAW,MAAM,EAAE,MAAM,MAAM,KAAG,GAAG,IAAI,MAkCvE,CAAA"}

package/dist/url/redirect-to-proxy.js

@@ -0,0 +1,44 @@
+import { isLocalUrl } from "./is-local-url.js";
+import { isRelativePath } from "./is-relative-path.js";
+const redirectToProxy = (proxyUrl, url) => {
+  try {
+    if (!shouldUseProxy(proxyUrl, url)) {
+      return url ?? "";
+    }
+    const newUrl = new URL(url);
+    const temporaryProxyUrl = isRelativePath(proxyUrl) ? `http://localhost${proxyUrl}` : proxyUrl;
+    newUrl.href = temporaryProxyUrl;
+    newUrl.searchParams.append("scalar_url", url);
+    const result = isRelativePath(proxyUrl) ? newUrl.toString().replace(/^http:\/\/localhost/, "") : newUrl.toString();
+    return result;
+  } catch {
+    return url ?? "";
+  }
+};
+const shouldUseProxy = (proxyUrl, url) => {
+  try {
+    if (!proxyUrl || !url) {
+      return false;
+    }
+    if (isRelativePath(url)) {
+      return false;
+    }
+    if (isRelativePath(proxyUrl)) {
+      return true;
+    }
+    if (isLocalUrl(proxyUrl)) {
+      return true;
+    }
+    if (isLocalUrl(url)) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+export {
+  redirectToProxy,
+  shouldUseProxy
+};
+//# sourceMappingURL=redirect-to-proxy.js.map

package/dist/url/redirect-to-proxy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/url/redirect-to-proxy.ts"],
+  "sourcesContent": ["import { isLocalUrl } from './is-local-url'\nimport { isRelativePath } from './is-relative-path'\n\n/**\n * Redirects the request to a proxy server with a given URL. But not for:\n *\n * - Relative URLs\n * - URLs that seem to point to a local IP (except the proxy is on the same domain)\n * - URLs that don't look like a domain\n **/\nexport const redirectToProxy = (proxyUrl?: string, url?: string): string => {\n  try {\n    if (!shouldUseProxy(proxyUrl, url)) {\n      return url ?? ''\n    }\n\n    // Create new URL object from url\n    const newUrl = new URL(url)\n\n    // Add temporary domain for relative proxy URLs\n    //\n    // Q: Why isn't proxyUrl type guarded?\n    // A: Type guarding works for one parameter only (as of now).\n    //\n    // Q: Why do we need to add http://localhost to relative proxy URLs?\n    // A: Because the `new URL()` would otherwise fail.\n    //\n    const temporaryProxyUrl = isRelativePath(proxyUrl as string) ? `http://localhost${proxyUrl}` : (proxyUrl as string)\n\n    // Rewrite the URL with the proxy\n    newUrl.href = temporaryProxyUrl\n\n    // Add the original URL as a query parameter\n    newUrl.searchParams.append('scalar_url', url)\n\n    // Remove the temporary domain if we added it, but only from the start of the URL\n    const result = isRelativePath(proxyUrl as string)\n      ? newUrl.toString().replace(/^http:\\/\\/localhost/, '')\n      : newUrl.toString()\n\n    return result\n  } catch {\n    return url ?? ''\n  }\n}\n\n/**\n * Returns false for requests to localhost, relative URLs, if no proxy is defined \u2026\n **/\nexport const shouldUseProxy = (proxyUrl?: string, url?: string): url is string => {\n  try {\n    // \u274C We don't have a proxy URL or the URL\n    if (!proxyUrl || !url) {\n      return false\n    }\n\n    // \u274C Request to relative URLs (won't be blocked by CORS anyway)\n    if (isRelativePath(url)) {\n      return false\n    }\n\n    // \u2705 Proxy URL is on the same domain (e.g. /proxy)\n    // It's more likely (not guaranteed, though) that the proxy has access to local domains.\n    if (isRelativePath(proxyUrl)) {\n      return true\n    }\n\n    // \u2705 Proxy URL is local\n    if (isLocalUrl(proxyUrl)) {\n      return true\n    }\n\n    // \u274C Requests to localhost\n    // We won't reach them from a (likely remote) proxy.\n    if (isLocalUrl(url)) {\n      return false\n    }\n\n    // \u2705 Seems fine (e.g. remote proxy + remote URL)\n    return true\n  } catch {\n    return false\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,kBAAkB;AAC3B,SAAS,sBAAsB;AASxB,MAAM,kBAAkB,CAAC,UAAmB,QAAyB;AAC1E,MAAI;AACF,QAAI,CAAC,eAAe,UAAU,GAAG,GAAG;AAClC,aAAO,OAAO;AAAA,IAChB;AAGA,UAAM,SAAS,IAAI,IAAI,GAAG;AAU1B,UAAM,oBAAoB,eAAe,QAAkB,IAAI,mBAAmB,QAAQ,KAAM;AAGhG,WAAO,OAAO;AAGd,WAAO,aAAa,OAAO,cAAc,GAAG;AAG5C,UAAM,SAAS,eAAe,QAAkB,IAC5C,OAAO,SAAS,EAAE,QAAQ,uBAAuB,EAAE,IACnD,OAAO,SAAS;AAEpB,WAAO;AAAA,EACT,QAAQ;AACN,WAAO,OAAO;AAAA,EAChB;AACF;AAKO,MAAM,iBAAiB,CAAC,UAAmB,QAAgC;AAChF,MAAI;AAEF,QAAI,CAAC,YAAY,CAAC,KAAK;AACrB,aAAO;AAAA,IACT;AAGA,QAAI,eAAe,GAAG,GAAG;AACvB,aAAO;AAAA,IACT;AAIA,QAAI,eAAe,QAAQ,GAAG;AAC5B,aAAO;AAAA,IACT;AAGA,QAAI,WAAW,QAAQ,GAAG;AACxB,aAAO;AAAA,IACT;AAIA,QAAI,WAAW,GAAG,GAAG;AACnB,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/package.json

@@ -14,7 +14,7 @@
     "helpers",
     "js"
   ],
-  "version": "0.2.8",
+  "version": "0.2.10",
   "engines": {
     "node": ">=20"
   },
@@ -88,7 +88,7 @@
     "CHANGELOG.md"
   ],
   "devDependencies": {
-    "jsdom": "26.1.0",
+    "jsdom": "27.4.0",
     "vite": "^7.3.1",
     "vitest": "4.0.16",
     "@scalar/build-tooling": "0.4.1"