@scalar/json-magic 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,9 @@
+
+> @scalar/json-magic@0.1.0 build /home/runner/work/scalar/scalar/packages/json-magic
+> scalar-build-esbuild
+
+@scalar/json-magic: Build completed in 90.13ms
+
+> @scalar/json-magic@0.1.0 types:build /home/runner/work/scalar/scalar/packages/json-magic
+> scalar-types-build
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @scalar/json-magic
+
+## 0.1.0
+
+### Minor Changes
+
+- 952bde2: feat(json-magic): move json tooling to the new package

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Scalar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,356 @@
+# json-magic
+
+[![Version](https://img.shields.io/npm/v/%40scalar/json-magic)](https://www.npmjs.com/package/@scalar/json-magic)
+[![Downloads](https://img.shields.io/npm/dm/%40scalar/json-magic)](https://www.npmjs.com/package/@scalar/json-magic)
+[![License](https://img.shields.io/npm/l/%40scalar%2Fjson-magic)](https://www.npmjs.com/package/@scalar/json-magic)
+[![Discord](https://img.shields.io/discord/1135330207960678410?style=flat&color=5865F2)](https://discord.gg/scalar)
+
+
+A collection of utilities for working with JSON objects, including diffing, conflict resolution, bundling and more.
+
+## bundle
+
+Bundle external references in a json object
+
+### Quick start
+
+```ts
+import { bundle } from '@scalar/json-magic/bundle'
+import { fetchUrls } from '@scalar/json-magic/bundle/plugins/browser'
+
+const result = await bundle({
+ $ref: 'http://example.com/document.json' 
+}, {
+  plugins: [fetchUrls()],
+  treeShake: false,
+})
+
+// get the bundled json object
+console.log(result)
+```
+
+#### Plugins
+
+If you are on a browser environment import plugins from `@scalar/json-magic/bundle/plugins/browser` while if you are on a node environment you can import from `@scalar/json-magic/bundle/plugins/node`
+
+##### fetchUrls
+This plugins handles all external urls. It works for both node.js and browser environment
+
+```ts
+import { bundle } from '@scalar/json-magic/bundle'
+import { fetchUrls } from '@scalar/json-magic/bundle/plugins/browser'
+
+const document = {
+  openapi: '3.1.0',
+  info: { title: 'Bundled API', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      User: { $ref: 'https://example.com/user-schema.json#' }
+    }
+  }
+}
+
+// This will bundle all external documents and turn all references from external into internal
+await bundle(document, {
+  plugins: [fetchUrls()],
+  treeShake: true  // <------  This flag will try to remove any unused part of the external document
+})
+
+console.log(document)
+```
+
+###### Limiting the number of concurrent requests
+
+```ts
+await bundle(document, {
+  plugins: [
+    fetchUrls({
+      limit: 10, // it should run at most 10 requests at the same time
+    }),
+  ],
+  treeShake: false
+})
+
+```
+
+###### Custom headers
+To pass custom headers to requests for specific domains you can configure the fetch plugin like the example
+
+```ts
+await bundle(
+  document,
+  {
+    plugins: [
+      fetchUrls({
+        // Pass custom headers
+        // The header will only be attached to the list of domains
+        headers: [
+          {
+            domains: ['example.com'],
+            headers: {
+              'Authorization': 'Bearer <TOKEN>'
+            }
+          }
+        ]
+      }),
+      readFiles(),
+    ],
+    treeShake: false
+  },
+)
+```
+
+###### Custom fetch function
+For advanced use cases like proxying requests or implementing custom network logic, you can provide your own fetch implementation. This allows you to handle things like CORS restrictions, custom authentication flows, or request/response transformations.
+
+```ts
+await bundle(
+  document,
+  {
+    plugins: [
+      fetchUrls({
+        // Custom fetcher function
+        fetch: async (input, init) => {
+          console.log('Custom fetch logic')
+          return fetch(input, init)
+        },
+      })
+      readFiles(),
+    ],
+    treeShake: false
+  },
+)
+```
+
+###### Bundle from remote url
+
+```ts
+const result = await bundle(
+  'https://example.com/openapi.json',
+  {
+    plugins: [
+      fetchUrls(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
+##### readFiles
+This plugins handles local files. Only works on node.js environment
+
+```ts
+import { bundle } from '@scalar/json-magic/bundle'
+import { readFiles } from '@scalar/json-magic/bundle/plugins/node'
+
+const document = {
+  openapi: '3.1.0',
+  info: { title: 'Bundled API', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      User: { $ref: './user-schema.json#' }
+    }
+  }
+}
+
+// This will bundle all external documents and turn all references from external into internal
+await bundle(document, {
+  plugins: [readFiles()],
+  treeShake: false
+})
+
+console.log(document)
+```
+
+###### Bundle from local file
+You can pass the file path directly but make sure to have the correct plugins to handle reading from the local files
+
+```ts
+const result = await bundle(
+  './input.json',
+  {
+    plugins: [
+      readFiles(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
+##### parseJson
+
+You can pass raw json string as input
+```ts
+import { bundle } from '@scalar/json-magic/bundle'
+import { parseJson } from '@scalar/json-magic/bundle/plugins/browser'
+
+const result = await bundle(
+  '{ "openapi": "3.1.1" }',
+  {
+    plugins: [
+      parseJson(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
+##### parseYaml
+
+You can pass raw yaml string as input
+```ts
+import { bundle } from '@scalar/json-magic/bundle'
+import { parseYaml } from '@scalar/json-magic/bundle/plugins/browser'
+
+const result = await bundle(
+  'openapi: "3.1.1"\n',
+  {
+    plugins: [
+      parseYaml(),
+    ],
+    treeShake: false
+  },
+)
+
+// Bundled document
+console.log(result)
+```
+
+#### Bundler Options
+
+##### depth
+
+The `depth` option controls how deeply the bundler will resolve `$ref` references. When you set `depth` to a number, the bundler will only follow references up to that level of nesting. This is useful for creating partial bundles or limiting resource usage.
+
+**Note:** When using `depth`, the resulting bundle may not be fully self-contained—some nested references deeper than the specified depth may remain unresolved. If you use `depth` together with the `visitedNodes` option, be aware that parent nodes may be marked as visited even if their child references have not been fully resolved yet. Use this option with care if you require a complete bundle.
+
+```ts
+import { bundle } from '@scalar/openapi-parser'
+import { fetchUrls } from '@scalar/openapi-parser/plugins-browser'
+
+await bundle(input, {
+  plugins: [fetchUrls()],
+  treeShake: false,
+  depth: 2,
+})
+```
+
+
+## dereference
+
+Dereference all `$ref` pointers in a JSON object, resolving both internal and external references.
+
+The `dereference` function can operate in two modes:
+
+- **Synchronous (`sync: true`)**: Only internal references (within the same object) are resolved. The result is wrapped in a magic proxy for reactive access. No network requests are made.
+- **Asynchronous (`sync: false` or omitted)**: Both internal and external references (e.g., URLs) are resolved. The function returns a Promise that resolves to the fully dereferenced object, also wrapped in a magic proxy.
+
+### Options
+
+- `sync` (`boolean`):  
+  - If `true`, resolves only internal references synchronously.
+  - If `false` (default), resolves both internal and external references asynchronously and returns a Promise.
+
+The result is an object with a `success` property. If dereferencing fails (e.g., due to unresolved external references), the result will include an `errors` array describing the issues encountered.
+
+```ts
+import { dereference } from '@scalar/json-magic/dereference'
+
+const result = dereference({ a: 'hello', b: { $ref: '#/a' } }, { sync: true })
+
+// Resolve internal references synchronously
+console.log(result)
+```
+
+To resolve also external references you need to set `sync: false`
+
+```ts
+import { dereference } from '@scalar/json-magic/dereference'
+
+const result = await dereference({ a: 'hello', b: { $ref: 'http://example.com/document.json#/somepath' } }, { sync: false })
+
+// Result with all internal and external references resolved
+console.log(result)
+```
+
+## diff
+
+This package provides a way to compare two json objects and get the differences, resolve conflicts and return conflicts that need to be resolved manually.
+
+### Quickstart
+
+
+```ts
+import { apply, diff, merge } from '@scalar/json-magic/diff'
+
+const baseObject = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Simple API',
+    description: 'A small OpenAPI specification example',
+    version: '1.0.0',
+  },
+}
+
+const objectV1 = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Simple API',
+    description: 'A small OpenAPI specification example',
+    version: '1.0.0',
+  },
+  change: 'This is a new property',
+}
+
+const objectV2 = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Simple API',
+    description: 'A small OpenAPI specification example',
+    version: '1.0.1',
+  },
+}
+
+// Merge the changes of both versions with the same parent object
+const { diffs, conflicts } = merge(
+  diff(baseObject, objectV1),
+  diff(baseObject, objectV2),
+)
+
+// Apply changes from v1 and v2 to the parent object to get the final object
+const finalDocument = apply(baseObject, diffs)
+```
+
+
+## magic-proxy
+
+A javascript proxy which resolves internal references when accessing a property
+
+### Quick start
+
+```ts
+import { createMagicProxy, getRaw } from '@scalar/json-magic/magic-proxy'
+
+const result = createMagicProxy({
+  a: 'hello',
+  b: '#/a'
+})
+
+// Resolved internal references for the input object
+console.log(result)
+
+const rawObject = getRaw(result)
+// Get the raw version of the object (unwrap it from the magic proxy)
+console.log(rawObject)
+```

package/dist/bundle/bundle.d.ts

@@ -0,0 +1,292 @@
+import type { UnknownObject } from '../types.js';
+/**
+ * Checks if a string is a remote URL (starts with http:// or https://)
+ * @param value - The URL string to check
+ * @returns true if the string is a remote URL, false otherwise
+ * @example
+ * ```ts
+ * isRemoteUrl('https://example.com/schema.json') // true
+ * isRemoteUrl('http://api.example.com/schemas/user.json') // true
+ * isRemoteUrl('#/components/schemas/User') // false
+ * isRemoteUrl('./local-schema.json') // false
+ * ```
+ */
+export declare function isRemoteUrl(value: string): boolean;
+/**
+ * Checks if a string represents a file path by ensuring it's not a remote URL,
+ * YAML content, or JSON content.
+ *
+ * @param value - The string to check
+ * @returns true if the string appears to be a file path, false otherwise
+ * @example
+ * ```ts
+ * isFilePath('./schemas/user.json') // true
+ * isFilePath('https://example.com/schema.json') // false
+ * isFilePath('{"type": "object"}') // false
+ * isFilePath('type: object') // false
+ * ```
+ */
+export declare function isFilePath(value: string): boolean;
+/**
+ * Checks if a string is a local reference (starts with #)
+ * @param value - The reference string to check
+ * @returns true if the string is a local reference, false otherwise
+ * @example
+ * ```ts
+ * isLocalRef('#/components/schemas/User') // true
+ * isLocalRef('https://example.com/schema.json') // false
+ * isLocalRef('./local-schema.json') // false
+ * ```
+ */
+export declare function isLocalRef(value: string): boolean;
+export type ResolveResult = {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+};
+/**
+ * Retrieves a nested value from an object using an array of property segments.
+ * @param target - The target object to traverse
+ * @param segments - Array of property names representing the path to the desired value
+ * @returns The value at the specified path, or undefined if the path doesn't exist
+ * @example
+ * const obj = { foo: { bar: { baz: 42 } } };
+ * getNestedValue(obj, ['foo', 'bar', 'baz']); // returns 42
+ */
+export declare function getNestedValue(target: Record<string, any>, segments: string[]): any;
+/**
+ * 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 declare function setValueAtPath(obj: any, path: string, value: any): void;
+/**
+ * Prefixes an internal JSON reference with a given path prefix.
+ * Takes a local reference (starting with #) and prepends the provided prefix segments.
+ *
+ * @param input - The internal reference string to prefix (must start with #)
+ * @param prefix - Array of path segments to prepend to the reference
+ * @returns The prefixed reference string
+ * @throws Error if input is not a local reference
+ * @example
+ * prefixInternalRef('#/components/schemas/User', ['definitions'])
+ * // Returns: '#/definitions/components/schemas/User'
+ */
+export declare function prefixInternalRef(input: string, prefix: string[]): string;
+/**
+ * Updates internal references in an object by adding a prefix to their paths.
+ * Recursively traverses the input object and modifies any local $ref references
+ * by prepending the given prefix to their paths. This is used when embedding external
+ * documents to maintain correct reference paths relative to the main document.
+ *
+ * @param input - The object to update references in
+ * @param prefix - Array of path segments to prepend to internal reference paths
+ * @returns void
+ * @example
+ * ```ts
+ * const input = {
+ *   foo: {
+ *     $ref: '#/components/schemas/User'
+ *   }
+ * }
+ * prefixInternalRefRecursive(input, ['definitions'])
+ * // Result:
+ * // {
+ * //   foo: {
+ * //     $ref: '#/definitions/components/schemas/User'
+ * //   }
+ * // }
+ * ```
+ */
+export declare function prefixInternalRefRecursive(input: unknown, prefix: string[]): void;
+/**
+ * Represents a plugin that handles resolving references from external sources.
+ * Plugins are responsible for fetching and processing data from different sources
+ * like URLs or the filesystem. Each plugin must implement validation to determine
+ * if it can handle a specific reference, and an execution function to perform
+ * the actual resolution.
+ *
+ * @property validate - Determines if this plugin can handle the given reference
+ * @property exec - Fetches and processes the reference, returning the resolved data
+ */
+export type Plugin = {
+    validate: (value: string) => boolean;
+    exec: (value: string) => Promise<ResolveResult>;
+};
+/**
+ * Configuration options for the bundler.
+ * Controls how external references are resolved and processed during bundling.
+ */
+type Config = {
+    /**
+     * Array of plugins that handle resolving references from different sources.
+     * Each plugin is responsible for fetching and processing data from specific sources
+     * like URLs or the filesystem.
+     */
+    plugins: Plugin[];
+    /**
+     * Optional root object that serves as the base document when bundling a subpart.
+     * This allows resolving references relative to the root document's location,
+     * ensuring proper path resolution for nested references.
+     */
+    root?: UnknownObject;
+    /**
+     * Optional maximum depth for reference resolution.
+     * Limits how deeply the bundler will follow and resolve nested $ref pointers.
+     * Useful for preventing infinite recursion or excessive resource usage.
+     */
+    depth?: number;
+    /**
+     * Optional cache to store promises of resolved references.
+     * Helps avoid duplicate fetches/reads of the same resource by storing
+     * the resolution promises for reuse.
+     */
+    cache?: Map<string, Promise<ResolveResult>>;
+    /**
+     * Cache of visited nodes during partial bundling.
+     * Used to prevent re-bundling the same tree multiple times when doing partial bundling,
+     * improving performance by avoiding redundant processing of already bundled sections.
+     */
+    visitedNodes?: Set<unknown>;
+    /**
+     * Enable tree shaking to optimize the bundle size.
+     * When enabled, only the parts of external documents that are actually referenced
+     * will be included in the final bundle.
+     */
+    treeShake: boolean;
+    /**
+     * Optional flag to generate a URL map.
+     * When enabled, tracks the original source URLs of bundled references
+     * in an x-ext-urls section for reference mapping.
+     */
+    urlMap?: boolean;
+    /**
+     * Optional function to compress input URLs or file paths before bundling.
+     * Returns either a Promise resolving to the compressed string or the compressed string directly.
+     */
+    compress?: (value: string) => Promise<string> | string;
+    /**
+     * Optional hooks to monitor the bundler's lifecycle.
+     * Allows tracking the progress and status of reference resolution.
+     */
+    hooks?: Partial<{
+        /** Called when starting to resolve a reference */
+        onResolveStart: (node: Record<string, unknown> & Record<'$ref', unknown>) => void;
+        /** Called when a reference resolution fails */
+        onResolveError: (node: Record<string, unknown> & Record<'$ref', unknown>) => void;
+        /** Called when a reference is successfully resolved */
+        onResolveSuccess: (node: Record<string, unknown> & Record<'$ref', unknown>) => void;
+    }>;
+};
+/**
+ * Bundles an OpenAPI specification by resolving all external references.
+ * This function traverses the input object recursively and embeds external $ref
+ * references into an x-ext section. External references can be URLs or local files.
+ * The original $refs are updated to point to their embedded content in the x-ext section.
+ * If the input is an object, it will be modified in place by adding an x-ext
+ * property to store resolved external references.
+ *
+ * @param input - The OpenAPI specification to bundle. Can be either an object or string.
+ *                If a string is provided, it will be resolved using the provided plugins.
+ *                If no plugin can process the input, the onReferenceError hook will be invoked
+ *                and an error will be emitted to the console.
+ * @param config - Configuration object containing plugins and options for bundling OpenAPI specifications
+ * @returns A promise that resolves to the bundled specification with all references embedded
+ * @example
+ * // Example with object input
+ * const spec = {
+ *   paths: {
+ *     '/users': {
+ *       $ref: 'https://example.com/schemas/users.yaml'
+ *     }
+ *   }
+ * }
+ *
+ * const bundled = await bundle(spec, {
+ *   plugins: [fetchUrls()],
+ *   treeShake: true,
+ *   urlMap: true,
+ *   hooks: {
+ *     onResolveStart: (ref) => console.log('Resolving:', ref.$ref),
+ *     onResolveSuccess: (ref) => console.log('Resolved:', ref.$ref),
+ *     onResolveError: (ref) => console.log('Failed to resolve:', ref.$ref)
+ *   }
+ * })
+ * // Result:
+ * // {
+ * //   paths: {
+ * //     '/users': {
+ * //       $ref: '#/x-ext/abc123'
+ * //     }
+ * //   },
+ * //   'x-ext': {
+ * //     'abc123': {
+ * //       // Resolved content from users.yaml
+ * //     }
+ * //   },
+ * //   'x-ext-urls': {
+ * //     'https://example.com/schemas/users.yaml': 'abc123'
+ * //   }
+ * // }
+ *
+ * // Example with URL input
+ * const bundledFromUrl = await bundle('https://example.com/openapi.yaml', {
+ *   plugins: [fetchUrls()],
+ *   treeShake: true,
+ *   urlMap: true,
+ *   hooks: {
+ *     onResolveStart: (ref) => console.log('Resolving:', ref.$ref),
+ *     onResolveSuccess: (ref) => console.log('Resolved:', ref.$ref),
+ *     onResolveError: (ref) => console.log('Failed to resolve:', ref.$ref)
+ *   }
+ * })
+ * // The function will first fetch the OpenAPI spec from the URL,
+ * // then bundle all its external references into the x-ext section
+ */
+export declare function bundle(input: UnknownObject | string, config: Config): Promise<object>;
+export {};
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/bundle/bundle.ts"],"names":[],"mappings":"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"}