@scalar/json-magic 0.12.2 → 0.12.4

package/dist/helpers/resolve-reference-path.js

@@ -1,17 +1,29 @@
-import path from "pathe";
-import { isHttpUrl } from "../helpers/is-http-url.js";
-const resolveReferencePath = (base, relativePath) => {
-  if (isHttpUrl(relativePath)) {
-    return relativePath;
-  }
-  if (isHttpUrl(base)) {
-    const baseUrl = new URL(base);
-    baseUrl.pathname = path.posix.resolve("/", path.dirname(baseUrl.pathname), relativePath);
-    return baseUrl.toString();
-  }
-  return path.resolve(path.dirname(base), relativePath);
+import path from 'pathe';
+import { isHttpUrl } from '../helpers/is-http-url.js';
+/**
+ * Resolves a reference path by combining a base path with a relative path.
+ * Handles both remote URLs and local file paths.
+ *
+ * @param base - The base path (can be a URL or local file path)
+ * @param relativePath - The relative path to resolve against the base
+ * @returns The resolved absolute path
+ * @example
+ * // Resolve remote URL
+ * resolveReferencePath('https://example.com/api/schema.json', 'user.json')
+ * // Returns: 'https://example.com/api/user.json'
+ *
+ * // Resolve local path
+ * resolveReferencePath('/path/to/schema.json', 'user.json')
+ * // Returns: '/path/to/user.json'
+ */
+export const resolveReferencePath = (base, relativePath) => {
+    if (isHttpUrl(relativePath)) {
+        return relativePath;
+    }
+    if (isHttpUrl(base)) {
+        const baseUrl = new URL(base);
+        baseUrl.pathname = path.posix.resolve('/', path.dirname(baseUrl.pathname), relativePath);
+        return baseUrl.toString();
+    }
+    return path.resolve(path.dirname(base), relativePath);
 };
-export {
-  resolveReferencePath
-};
-//# sourceMappingURL=resolve-reference-path.js.map

package/dist/helpers/set-value-at-path.js

@@ -1,28 +1,74 @@
-import { preventPollution } from "@scalar/helpers/object/prevent-pollution";
-import { getSegmentsFromPath } from "../helpers/get-segments-from-path.js";
-function setValueAtPath(obj, path, value) {
-  if (path === "") {
-    throw new Error("Cannot set value at root ('') pointer");
-  }
-  const parts = getSegmentsFromPath(path);
-  parts.forEach((part) => preventPollution(part));
-  let current = obj;
-  for (let i = 0; i < parts.length; i++) {
-    const key = parts[i];
-    const isLast = i === parts.length - 1;
-    const nextKey = parts[i + 1];
-    const shouldBeArray = /^\d+$/.test(nextKey ?? "");
-    if (isLast) {
-      current[key] = value;
-    } else {
-      if (!(key in current) || typeof current[key] !== "object") {
-        current[key] = shouldBeArray ? [] : {};
-      }
-      current = current[key];
+import { preventPollution } from '@scalar/helpers/object/prevent-pollution';
+import { getSegmentsFromPath } from '../helpers/get-segments-from-path.js';
+/**
+ * Sets a value at a specified path in an object, creating intermediate objects/arrays as needed.
+ * This function traverses the object structure and creates any missing intermediate objects
+ * or arrays based on the path segments. If the next segment is a numeric string, it creates
+ * an array instead of an object.
+ *
+ * ⚠️ Warning: Be careful with object keys that look like numbers (e.g. "123") as this function
+ * will interpret them as array indices and create arrays instead of objects. If you need to
+ * use numeric-looking keys, consider prefixing them with a non-numeric character.
+ *
+ * @param obj - The target object to set the value in
+ * @param path - The JSON pointer path where the value should be set
+ * @param value - The value to set at the specified path
+ * @throws {Error} If attempting to set a value at the root path ('')
+ *
+ * @example
+ * const obj = {}
+ * setValueAtPath(obj, '/foo/bar/0', 'value')
+ * // Result:
+ * // {
+ * //   foo: {
+ * //     bar: ['value']
+ * //   }
+ * // }
+ *
+ * @example
+ * const obj = { existing: { path: 'old' } }
+ * setValueAtPath(obj, '/existing/path', 'new')
+ * // Result:
+ * // {
+ * //   existing: {
+ * //     path: 'new'
+ * //   }
+ * // }
+ *
+ * @example
+ * // ⚠️ Warning: This will create an array instead of an object with key "123"
+ * setValueAtPath(obj, '/foo/123/bar', 'value')
+ * // Result:
+ * // {
+ * //   foo: [
+ * //     undefined,
+ * //     undefined,
+ * //     undefined,
+ * //     { bar: 'value' }
+ * //   ]
+ * // }
+ */
+export function setValueAtPath(obj, path, value) {
+    if (path === '') {
+        throw new Error("Cannot set value at root ('') pointer");
+    }
+    const parts = getSegmentsFromPath(path);
+    // Prevent prototype pollution
+    parts.forEach((part) => preventPollution(part));
+    let current = obj;
+    for (let i = 0; i < parts.length; i++) {
+        const key = parts[i];
+        const isLast = i === parts.length - 1;
+        const nextKey = parts[i + 1];
+        const shouldBeArray = /^\d+$/.test(nextKey ?? '');
+        if (isLast) {
+            current[key] = value;
+        }
+        else {
+            if (!(key in current) || typeof current[key] !== 'object') {
+                current[key] = shouldBeArray ? [] : {};
+            }
+            current = current[key];
+        }
     }
-  }
 }
-export {
-  setValueAtPath
-};
-//# sourceMappingURL=set-value-at-path.js.map

package/dist/helpers/to-relative-path.js

@@ -1,30 +1,42 @@
-import path from "pathe";
-import { isHttpUrl } from "../helpers/is-http-url.js";
-const toRelativePath = (input, base) => {
-  if (isHttpUrl(input) && isHttpUrl(base)) {
-    const inputUrl = new URL(input);
-    const baseUrl = new URL(base);
-    if (inputUrl.origin !== baseUrl.origin) {
-      return input;
+import path from 'pathe';
+import { isHttpUrl } from '../helpers/is-http-url.js';
+/**
+ * Converts an input path or URL to a relative path based on the provided base.
+ * Handles both remote URLs and local file system paths.
+ * - If both input and base are remote URLs and share the same origin, computes the relative pathname.
+ * - If base is a remote URL but input is local, returns a remote URL with a relative pathname.
+ * - If input is a remote URL but base is local, returns input as is.
+ * - Otherwise, computes the relative path between two local paths.
+ */
+export const toRelativePath = (input, base) => {
+    // Both input and base are remote URLs
+    if (isHttpUrl(input) && isHttpUrl(base)) {
+        const inputUrl = new URL(input);
+        const baseUrl = new URL(base);
+        // If origins aren't the same, return input as is
+        if (inputUrl.origin !== baseUrl.origin) {
+            return input;
+        }
+        // Get the directory of the base URL pathname (not the file itself)
+        const baseDir = path.dirname(path.posix.resolve('/', baseUrl.pathname));
+        const inputPath = path.posix.resolve('/', inputUrl.pathname);
+        // Return the relative path from baseDir to inputPath
+        return path.posix.relative(baseDir, inputPath);
     }
-    const baseDir2 = path.dirname(path.posix.resolve("/", baseUrl.pathname));
-    const inputPath2 = path.posix.resolve("/", inputUrl.pathname);
-    return path.posix.relative(baseDir2, inputPath2);
-  }
-  if (isHttpUrl(base)) {
-    const baseUrl = new URL(base);
-    const baseDir2 = path.dirname(path.posix.resolve("/", baseUrl.pathname));
-    baseUrl.pathname = path.posix.relative(baseDir2, path.posix.resolve("/", input));
-    return baseUrl.toString();
-  }
-  if (isHttpUrl(input)) {
-    return input;
-  }
-  const baseDir = path.dirname(path.resolve(base));
-  const inputPath = path.resolve(input);
-  return path.relative(baseDir, inputPath);
-};
-export {
-  toRelativePath
+    // Base is a remote URL, input is a local path
+    if (isHttpUrl(base)) {
+        const baseUrl = new URL(base);
+        const baseDir = path.dirname(path.posix.resolve('/', baseUrl.pathname));
+        // Set the pathname of the base URL to the relative path and return the URL as a string
+        baseUrl.pathname = path.posix.relative(baseDir, path.posix.resolve('/', input));
+        return baseUrl.toString();
+    }
+    // Input is a remote URL, base is a local path; just return input
+    if (isHttpUrl(input)) {
+        return input;
+    }
+    // Both input and base are local paths; return the relative path
+    const baseDir = path.dirname(path.resolve(base));
+    const inputPath = path.resolve(input);
+    return path.relative(baseDir, inputPath);
 };
-//# sourceMappingURL=to-relative-path.js.map

package/dist/helpers/unescape-json-pointer.js

@@ -1,7 +1,9 @@
-function unescapeJsonPointer(uri) {
-  return decodeURI(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
+/**
+ * Unescape JSON pointer
+ *
+ * Examples:
+ * /foo~1bar~0baz -> /foo/bar~baz
+ */
+export function unescapeJsonPointer(uri) {
+    return decodeURI(uri.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
-export {
-  unescapeJsonPointer
-};
-//# sourceMappingURL=unescape-json-pointer.js.map

package/dist/magic-proxy/index.js

@@ -1,6 +1 @@
-import { createMagicProxy, getRaw } from "./proxy.js";
-export {
-  createMagicProxy,
-  getRaw
-};
-//# sourceMappingURL=index.js.map
+export { createMagicProxy, getRaw } from './proxy.js';