@scalar/json-magic 0.1.0

package/src/utils/normalize.test.ts

@@ -0,0 +1,91 @@
+import { normalize } from '@/utils/normalize'
+import { describe, expect, it } from 'vitest'
+
+describe('normalize', () => {
+  it('returns undefined if the document is null', () => {
+    expect(normalize(null)).toEqual(undefined)
+  })
+
+  it('should parse JSON string specifications', () => {
+    const jsonString = '{"foo": "bar"}'
+    expect(normalize(jsonString)).toEqual({ foo: 'bar' })
+  })
+
+  it('should parse YAML string specifications', () => {
+    const yamlString = 'foo: bar\nbar: foo'
+    expect(normalize(yamlString)).toEqual({ foo: 'bar', bar: 'foo' })
+  })
+
+  it('should handle invalid YAML with custom maxAliasCount', () => {
+    const yamlString = `
+      aliases: &ref
+        - item1
+        - item2
+      items: *ref
+    `
+    expect(() => normalize(yamlString)).not.toThrow()
+  })
+
+  it('should return the same object if specification is already an object', () => {
+    const obj = { foo: 'bar' }
+    expect(normalize(obj)).toBe(obj)
+  })
+
+  it("doesn't freak out on invalid JSON strings ", () => {
+    // Missing quotes around property name
+    const malformedJson = '{ foo: "bar" }'
+    expect(normalize(malformedJson)).toEqual(undefined)
+  })
+
+  it('should handle empty string input', () => {
+    expect(normalize('')).toEqual(undefined)
+  })
+
+  it('should handle whitespace-only string input', () => {
+    expect(normalize('   ')).toEqual(undefined)
+  })
+
+  it('should handle complex nested structures', () => {
+    const complex = {
+      nested: {
+        array: [1, 2, 3],
+        object: {
+          foo: 'bar',
+        },
+      },
+    }
+    expect(normalize(complex)).toEqual(complex)
+  })
+
+  it('should handle invalid JSON and YAML strings gracefully', () => {
+    const invalidString = 'not a valid json or yaml'
+    expect(() => normalize(invalidString)).not.toThrow()
+  })
+
+  it('should handle non-string, non-object inputs', () => {
+    expect(normalize(42)).toEqual(42)
+    expect(normalize(true)).toEqual(true)
+    expect(normalize([1, 2, 3])).toEqual([1, 2, 3])
+  })
+
+  it('should handle deeply nested structures', () => {
+    const nested = { a: { b: { c: { d: { e: 'deep' } } } } }
+    expect(normalize(nested)).toEqual(nested)
+  })
+
+  it('should handle large input strings', () => {
+    const largeJson = JSON.stringify({ foo: 'bar'.repeat(10000) })
+    expect(normalize(largeJson)).toEqual({ foo: 'bar'.repeat(10000) })
+  })
+
+  it('should handle circular references', () => {
+    const circularObj: any = {}
+    circularObj.self = circularObj
+    expect(() => normalize(circularObj)).not.toThrow()
+  })
+
+  it('should handle special characters in strings', () => {
+    const specialCharJson = '{"foo": "bar\\n"}'
+    expect(normalize(specialCharJson)).toEqual({ foo: 'bar\n' })
+  })
+})

package/src/utils/normalize.ts

@@ -0,0 +1,34 @@
+import { parse } from 'yaml'
+
+/**
+ * Normalize a string (YAML, JSON, object) to a JavaScript datatype.
+ */
+export function normalize(content: any) {
+  if (content === null) {
+    return undefined
+  }
+
+  if (typeof content === 'string') {
+    if (content.trim() === '') {
+      return undefined
+    }
+
+    try {
+      return JSON.parse(content)
+    } catch (_error) {
+      // Does it look like YAML?
+      const hasColon = /^[^:]+:/.test(content)
+      const isJson = content.slice(0, 50).trimStart().startsWith('{')
+
+      if (!hasColon || isJson) {
+        return undefined
+      }
+
+      return parse(content, {
+        maxAliasCount: 10000,
+      })
+    }
+  }
+
+  return content
+}

package/src/utils/unescape-json-pointer.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { unescapeJsonPointer } from './unescape-json-pointer'
+
+describe('unescapeJsonPointer', async () => {
+  it('unescapes a slash', () => {
+    expect(unescapeJsonPointer('/foo~1bar~1baz')).toBe('/foo/bar/baz')
+  })
+
+  it('unescapes multiple slashes', () => {
+    expect(unescapeJsonPointer('#/paths/~1upload/post/responses/401/content/application~1problem+json/schema')).toBe(
+      '#/paths//upload/post/responses/401/content/application/problem+json/schema',
+    )
+  })
+
+  it('unescapes a tilde', () => {
+    expect(unescapeJsonPointer('/foo~0bar~0baz')).toBe('/foo~bar~baz')
+  })
+
+  it('unescapes a space', () => {
+    expect(unescapeJsonPointer('foo%20bar')).toBe('foo bar')
+  })
+})

package/src/utils/unescape-json-pointer.ts

@@ -0,0 +1,9 @@
+/**
+ * Unescape JSON pointer
+ *
+ * Examples:
+ * /foo~1bar~0baz -> /foo/bar~baz
+ */
+export function unescapeJsonPointer(uri: string) {
+  return decodeURI(uri.replace(/~1/g, '/').replace(/~0/g, '~'))
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"],
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist/"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    /** We need to remove these :) */
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "useUnknownInCatchVariables": false,
+    "exactOptionalPropertyTypes": false,
+    "allowJs": true,
+    "paths": {
+      "@/*": ["./src/*"],
+      "@test/*": ["./test/*"]
+    }
+  },
+  "include": ["src", "tests", "rollup.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,8 @@
+import { alias } from '@scalar/build-tooling'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  resolve: {
+    alias: alias(import.meta.url),
+  },
+})