@scalar/json-magic 0.8.1 → 0.8.3

package/src/helpers/convert-to-local-ref.test.ts

@@ -1,211 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { convertToLocalRef } from './convert-to-local-ref'
-
-describe('convertToLocalRef', () => {
-  const schemas = new Map([
-    ['https://example.com/schema1.json', '/components/schemas/Schema1'],
-    ['https://example.com/schema2.json', '/components/schemas/Schema2'],
-    ['https://example.com/schema1.json#anchor1', '/components/schemas/Schema1/definitions/Anchor1'],
-    ['https://example.com/schema2.json#anchor2', '/components/schemas/Schema2/definitions/Anchor2'],
-    ['https://example.com/current.json#currentAnchor', '/components/schemas/Current/definitions/CurrentAnchor'],
-  ])
-
-  const currentContext = 'https://example.com/current.json'
-
-  describe('external references with baseUrl', () => {
-    it('should resolve external reference without path or anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1')
-    })
-
-    it('should resolve external reference with JSON pointer path', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#/definitions/User', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/User')
-    })
-
-    it('should resolve external reference with anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#anchor1', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/Anchor1')
-    })
-
-    it('should return undefined for external reference not in schemas', () => {
-      const result = convertToLocalRef('https://example.com/unknown.json', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for external reference with unknown anchor', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#unknownAnchor', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('local references without baseUrl', () => {
-    it('should resolve local JSON pointer path', () => {
-      const result = convertToLocalRef('#/definitions/User', currentContext, schemas)
-
-      expect(result).toBe('definitions/User')
-    })
-
-    it('should resolve local JSON pointer path with multiple segments', () => {
-      const result = convertToLocalRef('#/components/schemas/User/properties/name', currentContext, schemas)
-
-      expect(result).toBe('components/schemas/User/properties/name')
-    })
-
-    it('should resolve local anchor reference', () => {
-      const result = convertToLocalRef('#currentAnchor', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Current/definitions/CurrentAnchor')
-    })
-
-    it('should return undefined for local anchor not in schemas', () => {
-      const result = convertToLocalRef('#unknownAnchor', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should return undefined for empty reference', () => {
-      const result = convertToLocalRef('', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for reference with only hash', () => {
-      const result = convertToLocalRef('#', currentContext, schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should return undefined for reference with only baseUrl and hash', () => {
-      const result = convertToLocalRef('https://example.com/schema1.json#', currentContext, schemas)
-
-      expect(result).toBe('/components/schemas/Schema1')
-    })
-
-    it('should handle empty currentContext', () => {
-      const result = convertToLocalRef('#anchor', '', schemas)
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should handle empty schemas map', () => {
-      const emptySchemas = new Map()
-      const result = convertToLocalRef('https://example.com/schema1.json', currentContext, emptySchemas)
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('complex scenarios', () => {
-    it('should handle nested JSON pointer paths', () => {
-      const result = convertToLocalRef(
-        'https://example.com/schema1.json#/definitions/User/properties/address/properties/street',
-        currentContext,
-        schemas,
-      )
-
-      expect(result).toBe('/components/schemas/Schema1/definitions/User/properties/address/properties/street')
-    })
-
-    it('should handle anchor with special characters', () => {
-      const schemasWithSpecialChars = new Map([
-        ['https://example.com/schema1.json', '/components/schemas/Schema1'],
-        [
-          'https://example.com/schema1.json#anchor-with-dashes',
-          '/components/schemas/Schema1/definitions/AnchorWithDashes',
-        ],
-        [
-          'https://example.com/schema1.json#anchor_with_underscores',
-          '/components/schemas/Schema1/definitions/AnchorWithUnderscores',
-        ],
-      ])
-
-      const result1 = convertToLocalRef(
-        'https://example.com/schema1.json#anchor-with-dashes',
-        currentContext,
-        schemasWithSpecialChars,
-      )
-
-      const result2 = convertToLocalRef(
-        'https://example.com/schema1.json#anchor_with_underscores',
-        currentContext,
-        schemasWithSpecialChars,
-      )
-
-      expect(result1).toBe('/components/schemas/Schema1/definitions/AnchorWithDashes')
-      expect(result2).toBe('/components/schemas/Schema1/definitions/AnchorWithUnderscores')
-    })
-
-    it('should handle different schema contexts', () => {
-      const differentContext = 'https://example.com/different.json'
-      const schemasWithDifferentContext = new Map([
-        [
-          'https://example.com/different.json#differentAnchor',
-          '/components/schemas/Different/definitions/DifferentAnchor',
-        ],
-      ])
-
-      const result = convertToLocalRef('#differentAnchor', differentContext, schemasWithDifferentContext)
-
-      expect(result).toBe('/components/schemas/Different/definitions/DifferentAnchor')
-    })
-  })
-
-  describe('real-world examples', () => {
-    it('should handle OpenAPI component references', () => {
-      const openApiSchemas = new Map([
-        ['https://api.example.com/schemas/user.json', '/components/schemas/User'],
-        ['https://api.example.com/schemas/user.json#/properties/id', '/components/schemas/User/properties/id'],
-        ['https://api.example.com/schemas/user.json#userProfile', '/components/schemas/User/definitions/UserProfile'],
-      ])
-
-      const result1 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      const result2 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json#/properties/name',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      const result3 = convertToLocalRef(
-        'https://api.example.com/schemas/user.json#userProfile',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      expect(result1).toBe('/components/schemas/User')
-      expect(result2).toBe('/components/schemas/User/properties/name')
-      expect(result3).toBe('/components/schemas/User/definitions/UserProfile')
-    })
-
-    it('should handle local component references in OpenAPI', () => {
-      const openApiSchemas = new Map([
-        ['https://api.example.com/openapi.json#userSchema', '/components/schemas/User'],
-        ['https://api.example.com/openapi.json#addressSchema', '/components/schemas/Address'],
-      ])
-
-      const result1 = convertToLocalRef('#userSchema', 'https://api.example.com/openapi.json', openApiSchemas)
-
-      const result2 = convertToLocalRef(
-        '#/components/schemas/User/properties/name',
-        'https://api.example.com/openapi.json',
-        openApiSchemas,
-      )
-
-      expect(result1).toBe('/components/schemas/User')
-      expect(result2).toBe('components/schemas/User/properties/name')
-    })
-  })
-})

package/src/helpers/convert-to-local-ref.ts

@@ -1,43 +0,0 @@
-/**
- * Translates a JSON Reference ($ref) to a local object path within the root schema.
- *
- * @param ref - The JSON Reference string (e.g., "#/foo/bar", "other.json#/baz", "other.json#anchor")
- * @param currentContext - The current base context (usually the $id of the current schema or parent)
- * @param schemas - A map of schema identifiers ($id, $anchor) to their local object paths
- * @returns The local object path as a string, or undefined if the reference cannot be resolved
- */
-export const convertToLocalRef = (
-  ref: string,
-  currentContext: string,
-  schemas: Map<string, string>,
-): string | undefined => {
-  // Split the reference into base URL and path/anchor (e.g., "foo.json#/bar" => ["foo.json", "/bar"])
-  const [baseUrl, pathOrAnchor] = ref.split('#', 2)
-
-  if (baseUrl) {
-    if (!schemas.has(baseUrl)) {
-      return undefined
-    }
-
-    if (!pathOrAnchor) {
-      return schemas.get(baseUrl)
-    }
-
-    // If the pathOrAnchor is a JSON pointer, we need to append it to the baseUrl
-    if (pathOrAnchor.startsWith('/')) {
-      return `${schemas.get(baseUrl)}${pathOrAnchor}`
-    }
-
-    // If the pathOrAnchor is an anchor, we need to return the anchor
-    return schemas.get(`${baseUrl}#${pathOrAnchor}`)
-  }
-
-  if (pathOrAnchor) {
-    if (pathOrAnchor.startsWith('/')) {
-      return pathOrAnchor.slice(1)
-    }
-    return schemas.get(`${currentContext}#${pathOrAnchor}`)
-  }
-
-  return undefined
-}

package/src/helpers/escape-json-pointer.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { escapeJsonPointer } from './escape-json-pointer'
-
-describe('escapeJsonPointer', () => {
-  it('should escape a slash', () => {
-    expect(escapeJsonPointer('application/json')).toBe('application~1json')
-  })
-
-  it('should escape multiple slashes', () => {
-    expect(escapeJsonPointer('/api/users/{id}/reports')).toBe('~1api~1users~1{id}~1reports')
-  })
-})

package/src/helpers/escape-json-pointer.ts

@@ -1,8 +0,0 @@
-/**
- * Escapes a JSON pointer string.
- *
- * Example: `/foo/bar~baz` -> `/foo~1bar~0baz`
- */
-export function escapeJsonPointer(str: string) {
-  return str.replace(/~/g, '~0').replace(/\//g, '~1')
-}

package/src/helpers/generate-hash.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { generateHash } from './generate-hash'
-
-describe('generateHash', () => {
-  it('generates a hash from a simple string', async () => {
-    const result = await generateHash('hello world')
-
-    // Should return a non-empty string
-    expect(result).toBeTruthy()
-    expect(typeof result).toBe('string')
-    expect(result.length).toBeGreaterThan(0)
-  })
-
-  it('produces consistent hashes for the same input', async () => {
-    const input = 'consistent-test-string'
-    const hash1 = await generateHash(input)
-    const hash2 = await generateHash(input)
-    const hash3 = await generateHash(input)
-
-    // Same input should always produce the same hash
-    expect(hash1).toBe(hash2)
-    expect(hash2).toBe(hash3)
-  })
-
-  it('produces different hashes for different inputs', async () => {
-    const hash1 = await generateHash('first string')
-    const hash2 = await generateHash('second string')
-    const hash3 = await generateHash('first strinG') // Case-sensitive
-
-    // Different inputs should produce different hashes
-    expect(hash1).not.toBe(hash2)
-    expect(hash1).not.toBe(hash3)
-    expect(hash2).not.toBe(hash3)
-  })
-
-  it('handles empty string', async () => {
-    const result = await generateHash('')
-
-    // Should handle empty strings without throwing
-    expect(result).toBeTruthy()
-    expect(typeof result).toBe('string')
-
-    // Empty string should produce a consistent hash
-    const result2 = await generateHash('')
-    expect(result).toBe(result2)
-  })
-
-  it('handles special characters and unicode', async () => {
-    const inputs = [
-      '🚀 emoji test',
-      'special chars: !@#$%^&*()',
-      'unicode: こんにちは世界',
-      'newlines\nand\ttabs',
-      'mixed: 👾 special!@# unicode: 你好',
-    ]
-
-    const hashes = await Promise.all(inputs.map((input) => generateHash(input)))
-
-    // All should produce valid hashes
-    hashes.forEach((hash) => {
-      expect(hash).toBeTruthy()
-      expect(typeof hash).toBe('string')
-    })
-
-    // All should be unique
-    const uniqueHashes = new Set(hashes)
-    expect(uniqueHashes.size).toBe(inputs.length)
-
-    // Should be consistent on repeated calls
-    const repeatedHash = await generateHash('🚀 emoji test')
-    expect(repeatedHash).toBe(hashes[0])
-  })
-})

package/src/helpers/generate-hash.ts

@@ -1,29 +0,0 @@
-import xxhash from 'xxhash-wasm'
-
-let hasherInstance: Awaited<ReturnType<typeof xxhash>> | null = null
-
-/**
- * Initialize the xxhash hasher instance lazily
- *
- * This is just a workaround because we cannot use top level await in a UMD module (standalone references)
- */
-const getHasher = async () => {
-  if (!hasherInstance) {
-    hasherInstance = await xxhash()
-  }
-  return hasherInstance
-}
-
-/**
- * Generate a hash from a string using the xxhash algorithm
- *
- * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
- * So this is just a wrapper around the xxhash-wasm library instead.
- *
- * @param input - The string to hash
- * @returns A Promise that resolves to the hash of the input string
- */
-export const generateHash = async (input: string): Promise<string> => {
-  const { h64ToString } = await getHasher()
-  return h64ToString(input)
-}