@o3co/ts.hocon 0.1.0 → 0.1.1

package/tests/lightbend/testdata/validate-reference.conf

@@ -1,32 +0,0 @@
-string1="foo"
-string2="bar"
-string3="baz"
-string4="hello"
-int1=10
-int2=11
-int3=12
-float1=3.14
-float2=3.2
-float3=3.3
-bool1=true
-bool2=false
-bool3=true
-null1=null
-null2=null
-null3=null
-object1={ a : b }
-object2={ c : d }
-object3={ e : f }
-array1=[1,2,3]
-array2=[a,b,c]
-array3=[true, true, false]
-array4=[{}, {}]
-array5=[]
-emptyArray1=[]
-emptyArray2=[]
-willBeMissing=90009
-
-a.b.c.d.e.f.g = true
-a.b.c.d.e.f.h = true
-a.b.c.d.e.f.i = true
-a.b.c.d.e.f.j = true

package/tests/parse.test.ts

@@ -1,44 +0,0 @@
-// tests/parse.test.ts
-import { describe, it, expect } from 'vitest'
-import { parse, parseAsync } from '../src/parse.js'
-import { ParseError, ResolveError } from '../src/errors.js'
-
-describe('parse()', () => {
-  it('parses basic config', () => {
-    const c = parse('server { host = "localhost"\nport = 8080 }')
-    expect(c.getString('server.host')).toBe('localhost')
-    expect(c.getNumber('server.port')).toBe(8080)
-  })
-
-  it('resolves substitutions end-to-end', () => {
-    const c = parse('base = "hello"\ngreeting = ${base}" world"')
-    expect(c.getString('greeting')).toBe('hello world')
-  })
-
-  it('uses env option for substitution fallback', () => {
-    const c = parse('val = ${MY_ENV}', { env: { MY_ENV: 'from-env' } })
-    expect(c.getString('val')).toBe('from-env')
-  })
-
-  it('uses process.env as default env', () => {
-    process.env['HOCON_TEST_VAR'] = 'test-value'
-    const c = parse('val = ${HOCON_TEST_VAR}')
-    expect(c.getString('val')).toBe('test-value')
-    delete process.env['HOCON_TEST_VAR']
-  })
-
-  it('throws ParseError for syntax errors', () => {
-    expect(() => parse('{ unclosed')).toThrow(ParseError)
-  })
-
-  it('throws ResolveError for unresolved substitution', () => {
-    expect(() => parse('x = ${missing}')).toThrow(ResolveError)
-  })
-})
-
-describe('parseAsync()', () => {
-  it('parses basic config asynchronously', async () => {
-    const c = await parseAsync('host = "localhost"')
-    expect(c.getString('host')).toBe('localhost')
-  })
-})

package/tests/parser.test.ts

@@ -1,154 +0,0 @@
-// tests/parser.test.ts
-import { describe, it, expect } from 'vitest'
-import { tokenize } from '../src/internal/lexer/lexer.js'
-import { parseTokens } from '../src/internal/parser/parser.js'
-import type { AstNode } from '../src/internal/parser/ast.js'
-
-function parse(input: string): AstNode {
-  return parseTokens(tokenize(input))
-}
-
-describe('parseTokens', () => {
-  it('parses empty input as empty object', () => {
-    const node = parse('')
-    expect(node.kind).toBe('object')
-    if (node.kind === 'object') expect(node.fields).toHaveLength(0)
-  })
-
-  it('parses key = value', () => {
-    const node = parse('host = "localhost"')
-    expect(node.kind).toBe('object')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['host'])
-      expect(node.fields[0]!.value.kind).toBe('scalar')
-    }
-  })
-
-  it('parses key: value (colon syntax)', () => {
-    const node = parse('port: 8080')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['port'])
-    }
-  })
-
-  it('parses dot-notation keys', () => {
-    const node = parse('server.host = "localhost"')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['server', 'host'])
-    }
-  })
-
-  it('does not split quoted keys at dots', () => {
-    const node = parse('"a.b" = 1')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['a.b'])
-    }
-  })
-
-  it('parses nested objects (brace syntax)', () => {
-    const node = parse('server { host = "localhost" }')
-    expect(node.kind).toBe('object')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['server'])
-      expect(node.fields[0]!.value.kind).toBe('object')
-    }
-  })
-
-  it('parses arrays', () => {
-    const node = parse('list = [1, 2, 3]')
-    if (node.kind === 'object') {
-      const arr = node.fields[0]!.value
-      expect(arr.kind).toBe('array')
-      if (arr.kind === 'array') expect(arr.items).toHaveLength(3)
-    }
-  })
-
-  it('parses boolean and null scalars', () => {
-    const node = parse('a = true\nb = false\nc = null')
-    if (node.kind === 'object') {
-      const vals = node.fields.map(f => f.value)
-      expect(vals[0]!.kind === 'scalar' && vals[0]!.value).toBe(true)
-      expect(vals[1]!.kind === 'scalar' && vals[1]!.value).toBe(false)
-      expect(vals[2]!.kind === 'scalar' && vals[2]!.value).toBe(null)
-    }
-  })
-
-  it('parses integer scalars', () => {
-    const node = parse('port = 8080')
-    if (node.kind === 'object') {
-      const val = node.fields[0]!.value
-      expect(val.kind === 'scalar' && val.value).toBe(8080)
-    }
-  })
-
-  it('parses float scalars', () => {
-    const node = parse('ratio = 1.5')
-    if (node.kind === 'object') {
-      const val = node.fields[0]!.value
-      expect(val.kind === 'scalar' && val.value).toBe(1.5)
-    }
-  })
-
-  it('parses substitutions', () => {
-    const node = parse('host = ${server.host}')
-    if (node.kind === 'object') {
-      const val = node.fields[0]!.value
-      expect(val.kind).toBe('subst')
-      if (val.kind === 'subst') {
-        expect(val.path).toBe('server.host')
-        expect(val.optional).toBe(false)
-      }
-    }
-  })
-
-  it('parses optional substitutions', () => {
-    const node = parse('host = ${?server.host}')
-    if (node.kind === 'object') {
-      const val = node.fields[0]!.value
-      if (val.kind === 'subst') expect(val.optional).toBe(true)
-    }
-  })
-
-  it('parses concat (adjacent tokens on same line, no space)', () => {
-    const node = parse('url = "http://"${host}":8080"')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.value.kind).toBe('concat')
-    }
-  })
-
-  it('parses += append operator', () => {
-    const node = parse('list += 1')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.append).toBe(true)
-    }
-  })
-
-  it('parses include directive', () => {
-    const node = parse('include "other.conf"')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toHaveLength(0)
-      expect(node.fields[0]!.value.kind).toBe('include')
-    }
-  })
-
-  it('parses include file(...) syntax', () => {
-    const node = parse('include file("other.conf")')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.value.kind).toBe('include')
-    }
-  })
-
-  it('chains two quoted key segments with a dot', () => {
-    const node = parse('"a"."b" = 1')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['a', 'b'])
-    }
-  })
-
-  it('chains three quoted key segments with dots', () => {
-    const node = parse('"a"."b"."c" = 1')
-    if (node.kind === 'object') {
-      expect(node.fields[0]!.key).toEqual(['a', 'b', 'c'])
-    }
-  })
-})

package/tests/resolver.test.ts

@@ -1,159 +0,0 @@
-// tests/resolver.test.ts
-import { describe, it, expect } from 'vitest'
-import { tokenize } from '../src/internal/lexer/lexer.js'
-import { parseTokens } from '../src/internal/parser/parser.js'
-import { resolve } from '../src/internal/resolver/resolver.js'
-import type { HoconValue } from '../src/value.js'
-import { ResolveError } from '../src/errors.js'
-
-function resolveStr(input: string, env: Record<string, string> = {}): HoconValue {
-  const ast = parseTokens(tokenize(input))
-  return resolve(ast, { env, baseDir: undefined, readFileSync: () => { throw new Error('no fs') } })
-}
-
-function obj(v: HoconValue): Map<string, HoconValue> {
-  if (v.kind !== 'object') throw new Error('expected object')
-  return v.fields
-}
-
-describe('Resolver - Pass 1 (structure)', () => {
-  it('resolves simple string value', () => {
-    const v = resolveStr('host = "localhost"')
-    expect(obj(v).get('host')).toEqual({ kind: 'scalar', value: 'localhost' })
-  })
-
-  it('resolves number value', () => {
-    const v = resolveStr('port = 8080')
-    expect(obj(v).get('port')).toEqual({ kind: 'scalar', value: 8080 })
-  })
-
-  it('resolves nested objects', () => {
-    const v = resolveStr('server { host = "localhost" }')
-    const server = obj(v).get('server')
-    expect(server?.kind).toBe('object')
-  })
-
-  it('merges duplicate object keys', () => {
-    const v = resolveStr('server { host = "a" }\nserver { port = 8080 }')
-    const server = obj(v).get('server')
-    if (server?.kind === 'object') {
-      expect(server.fields.has('host')).toBe(true)
-      expect(server.fields.has('port')).toBe(true)
-    }
-  })
-
-  it('last value wins for scalar keys', () => {
-    const v = resolveStr('x = 1\nx = 2')
-    expect(obj(v).get('x')).toEqual({ kind: 'scalar', value: 2 })
-  })
-
-  it('resolves arrays', () => {
-    const v = resolveStr('list = [1, 2, 3]')
-    const arr = obj(v).get('list')
-    expect(arr?.kind).toBe('array')
-    if (arr?.kind === 'array') expect(arr.items).toHaveLength(3)
-  })
-
-  it('handles += on existing array', () => {
-    const v = resolveStr('list = [1, 2]\nlist += 3')
-    const arr = obj(v).get('list')
-    if (arr?.kind === 'array') expect(arr.items).toHaveLength(3)
-  })
-
-  it('handles += on missing key (starts from empty array)', () => {
-    const v = resolveStr('list += 1')
-    const arr = obj(v).get('list')
-    if (arr?.kind === 'array') expect(arr.items).toHaveLength(1)
-  })
-
-  it('preserves Map insertion order', () => {
-    const v = resolveStr('c = 3\na = 1\nb = 2')
-    const keys = [...obj(v).keys()]
-    expect(keys).toEqual(['c', 'a', 'b'])
-  })
-})
-
-describe('Resolver - Pass 2 (substitutions)', () => {
-  it('resolves ${path} substitution', () => {
-    const v = resolveStr('host = "localhost"\nurl = ${host}')
-    expect(obj(v).get('url')).toEqual({ kind: 'scalar', value: 'localhost' })
-  })
-
-  it('resolves nested path substitution', () => {
-    const v = resolveStr('server { host = "x" }\nhost = ${server.host}')
-    expect(obj(v).get('host')).toEqual({ kind: 'scalar', value: 'x' })
-  })
-
-  it('resolves ${?path} optional substitution (path exists)', () => {
-    const v = resolveStr('a = 1\nb = ${?a}')
-    expect(obj(v).get('b')).toEqual({ kind: 'scalar', value: 1 })
-  })
-
-  it('drops field for ${?path} optional substitution (path missing)', () => {
-    const v = resolveStr('b = ${?missing}')
-    expect(obj(v).get('b')).toBeUndefined()
-  })
-
-  it('throws ResolveError for unresolved mandatory substitution', () => {
-    expect(() => resolveStr('b = ${missing}')).toThrow(ResolveError)
-  })
-
-  it('falls back to env for unresolved substitution', () => {
-    const v = resolveStr('b = ${MY_VAR}', { MY_VAR: 'hello' })
-    expect(obj(v).get('b')).toEqual({ kind: 'scalar', value: 'hello' })
-  })
-
-  it('resolves self-referential substitution', () => {
-    const v = resolveStr('path = "/usr"\npath = ${path}:/extra')
-    // concat resolves: "/usr" + ":/extra" = "/usr:/extra"
-    const result = obj(v).get('path')
-    if (result?.kind === 'scalar') expect(String(result.value)).toContain('/usr')
-  })
-
-  it('resolves string concat with substitution', () => {
-    const v = resolveStr('host = "localhost"\nurl = "http://"${host}')
-    const result = obj(v).get('url')
-    expect(result?.kind === 'scalar' && result.value).toBe('http://localhost')
-  })
-
-  it('throws ResolveError on circular substitution', () => {
-    expect(() => resolveStr('a = ${b}\nb = ${a}')).toThrow(ResolveError)
-  })
-
-  it('resolves forward-reference substitution', () => {
-    const v = resolveStr('url = $' + '{host}\nhost = "localhost"')
-    expect(obj(v).get('url')).toEqual({ kind: 'scalar', value: 'localhost' })
-  })
-})
-
-describe('Resolver - include', () => {
-  function resolveWithFs(input: string, files: Record<string, string>): HoconValue {
-    const ast = parseTokens(tokenize(input))
-    return resolve(ast, {
-      env: {},
-      baseDir: '/fake',
-      readFileSync: (p: string) => {
-        const key = p.replace('/fake/', '')
-        if (!(key in files)) throw new Error(`file not found: ${p}`)
-        return files[key] ?? ''
-      },
-    })
-  }
-
-  it('merges included file into current object', () => {
-    const v = resolveWithFs('include "other.conf"\nport = 8080', {
-      'other.conf': 'host = "localhost"',
-    })
-    expect(obj(v).get('host')).toEqual({ kind: 'scalar', value: 'localhost' })
-    expect(obj(v).get('port')).toEqual({ kind: 'scalar', value: 8080 })
-  })
-
-  it('throws ResolveError on circular include', () => {
-    expect(() =>
-      resolveWithFs('include "a.conf"', {
-        'a.conf': 'include "b.conf"',
-        'b.conf': 'include "a.conf"',
-      })
-    ).toThrow(ResolveError)
-  })
-})

package/tests/zod.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { z } from 'zod'
-import { parse } from '../src/parse.js'
-import { validate, getValidated } from '../src/zod.js'
-
-const cfg = parse(`
-  server {
-    host = "localhost"
-    port = 8080
-  }
-  debug = false
-`)
-
-describe('validate()', () => {
-  it('validates and returns typed object', () => {
-    const Schema = z.object({
-      server: z.object({
-        host: z.string(),
-        port: z.number().int(),
-      }),
-      debug: z.boolean(),
-    })
-    const result = validate(cfg, Schema)
-    expect(result.server.host).toBe('localhost')
-    expect(result.server.port).toBe(8080)
-    expect(result.debug).toBe(false)
-  })
-
-  it('throws ZodError on schema mismatch', () => {
-    const Schema = z.object({ server: z.object({ host: z.number() }) })
-    expect(() => validate(cfg, Schema)).toThrow()
-  })
-
-  it('supports Zod transforms (e.g., coerce)', () => {
-    const c = parse('timeout = "30"')
-    const Schema = z.object({ timeout: z.coerce.number() })
-    const result = validate(c, Schema)
-    expect(result.timeout).toBe(30)
-  })
-})
-
-describe('getValidated()', () => {
-  it('returns typed value at path', () => {
-    const port = getValidated(cfg, 'server.port', z.number().int())
-    expect(port).toBe(8080)
-    // TypeScript should infer `port` as `number`
-    const _check: number = port
-  })
-
-  it('throws ZodError on schema mismatch at path', () => {
-    expect(() => getValidated(cfg, 'server.host', z.number())).toThrow()
-  })
-
-  it('throws on missing path', () => {
-    expect(() => getValidated(cfg, 'missing.path', z.string())).toThrow()
-  })
-})

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "lib": ["ES2020"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "skipLibCheck": true
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: {
-    index: 'src/index.ts',
-    zod: 'src/zod.ts',
-  },
-  format: ['esm', 'cjs'],
-  dts: true,
-  clean: true,
-  splitting: false,
-})

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    include: ['tests/**/*.test.ts'],
-  },
-})