@scalar/validation 0.1.0 → 0.3.0

package/src/schema.ts

@@ -1,63 +1,93 @@
+/**
+ * Optional metadata for type generation and documentation.
+ * - typeName: Used as the exported TypeScript type name if valid.
+ * - typeComment: Adds a JSDoc comment to the generated type declaration.
+ */
+type Documentation = Partial<{
+  /** Adds a JSDoc comment to the generated type declaration. */
+  typeComment: string
+  /** Used as the exported TypeScript type name if valid. */
+  typeName: string
+}>
+
 /** Schema for finite numeric values. {@link Static} resolves to `number`. */
 export type NumberSchema = {
   type: 'number'
-}
+} & Documentation
 
 /** Schema for string values. {@link Static} resolves to `string`. */
 export type StringSchema = {
   type: 'string'
-}
+} & Documentation
 
 /** Schema for boolean values. {@link Static} resolves to `boolean`. */
 export type BooleanSchema = {
   type: 'boolean'
-}
+} & Documentation
 
 /** Schema for `null`. {@link Static} resolves to `null`. */
 export type NullableSchema = {
   type: 'nullable'
-}
+} & Documentation
 
 /** Schema for a missing or omitted value. {@link Static} resolves to `undefined`. */
 export type NotDefinedSchema = {
   type: 'notDefined'
-}
+} & Documentation
 
 /** Schema that accepts any value without narrowing. {@link Static} resolves to `any`. */
 export type AnySchema = {
   type: 'any'
-}
+} & Documentation
 
 /** Schema for homogeneous lists. {@link Static} resolves to an array of the item static type. */
 export type ArraySchema<Item extends Schema> = {
   type: 'array'
   items: Item
-}
+} & Documentation
 
 /** Schema for key-value maps with uniform value shape. Keys are constrained to string or number schemas. */
 export type RecordSchema<Key extends StringSchema | NumberSchema | AnySchema, Value extends Schema> = {
   type: 'record'
   key: Key
   value: Value
-}
+} & Documentation
 
 /** Schema for objects with a fixed set of named properties, each with its own schema. */
 export type ObjectSchema<Properties extends Record<string, Schema>> = {
   type: 'object'
   properties: Properties
-}
+} & Documentation
 
 /** Schema that matches if any member schema matches (discriminated union when literals or object tags differ). */
 export type UnionSchema<Schemas extends Schema[]> = {
   type: 'union'
   schemas: Schemas
-}
+} & Documentation
+
+/**
+ * Schema that accepts `undefined` or a value matching the inner schema.
+ * In {@link Static} and type generation, object properties use `key?:` instead of `T | undefined`.
+ */
+export type OptionalSchema<S extends Schema> = {
+  type: 'optional'
+  schema: S
+} & Documentation
+
+/**
+ * `UnionSchema<any>` avoids a variance pitfall: `UnionSchema<[A, B]>` is not assignable to
+ * `UnionSchema<ObjectSchema<any>[]>`, which breaks `infer` when resolving `Static`.
+ */
+export type IntersectionSchema<Schemas extends readonly (ObjectSchema<any> | UnionSchema<any>)[]> = {
+  type: 'intersection'
+  schemas: Schemas
+} & Documentation
 
 /** Schema for a single exact constant (string, number, boolean, or bigint). {@link Static} is that literal type. */
 export type LiteralSchema<T extends string | number | boolean | bigint> = {
   type: 'literal'
   value: T
-}
+} & Documentation
 
 /**
  * Schema for self-referential or recursive types (such as trees or linked lists).
@@ -90,59 +120,100 @@ export type Schema =
   | RecordSchema<any, any>
   | ObjectSchema<Record<string, any>>
   | UnionSchema<any[]>
+  | OptionalSchema<any>
+  | IntersectionSchema<readonly (ObjectSchema<any> | UnionSchema<ObjectSchema<any>[]>)[]>
   | LiteralSchema<any>
   | LazySchema<any>
   | EvaluateSchema<any>
 
-const number = (): NumberSchema => ({
+const number = (options?: Documentation): NumberSchema => ({
   type: 'number',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const string = (): StringSchema => ({
+const string = (options?: Documentation): StringSchema => ({
   type: 'string',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const boolean = (): BooleanSchema => ({
+const boolean = (options?: Documentation): BooleanSchema => ({
   type: 'boolean',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const nullable = (): NullableSchema => ({
+const nullable = (options?: Documentation): NullableSchema => ({
   type: 'nullable',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const notDefined = (): NotDefinedSchema => ({
+const notDefined = (options?: Documentation): NotDefinedSchema => ({
   type: 'notDefined',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const any = (): AnySchema => ({
+const any = (options?: Documentation): AnySchema => ({
   type: 'any',
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const array = <Item extends Schema>(items: Item): ArraySchema<Item> => ({
+const array = <Item extends Schema>(items: Item, options?: Documentation): ArraySchema<Item> => ({
   type: 'array',
   items,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
 const record = <Key extends StringSchema | AnySchema, Value extends Schema>(
   key: Key,
   value: Value,
+  options?: Documentation,
 ): RecordSchema<Key, Value> => ({
   type: 'record',
   key,
   value,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const object = <Properties extends Record<string, Schema>>(properties: Properties): ObjectSchema<Properties> => ({
+const object = <Properties extends Record<string, Schema>>(
+  properties: Properties,
+  options?: Documentation,
+): ObjectSchema<Properties> => ({
   type: 'object',
   properties,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const union = <Schemas extends Schema[]>(schemas: Schemas): UnionSchema<Schemas> => ({
+const union = <Schemas extends Schema[]>(schemas: Schemas, options?: Documentation): UnionSchema<Schemas> => ({
   type: 'union',
   schemas,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
+})
+
+const intersection = <const Schemas extends readonly (ObjectSchema<any> | UnionSchema<ObjectSchema<any>[]>)[]>(
+  schemas: Schemas,
+  options?: Documentation,
+): IntersectionSchema<Schemas> => ({
+  type: 'intersection',
+  schemas,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
 })
 
-const optional = <S extends Schema>(schema: S) => union([schema, notDefined()])
+const optional = <S extends Schema>(schema: S, options?: Documentation): OptionalSchema<S> => ({
+  type: 'optional',
+  schema,
+  typeName: options?.typeName,
+  typeComment: options?.typeComment,
+})
 
 const literal = <Value extends string | number | boolean | bigint>(value: Value): LiteralSchema<Value> => ({
   type: 'literal',
@@ -171,6 +242,7 @@ export {
   record,
   object,
   union,
+  intersection,
   optional,
   literal,
   lazy,

package/src/typegen.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  any,
+  array,
+  boolean,
+  evaluate,
+  lazy,
+  intersection,
+  literal,
+  notDefined,
+  nullable,
+  number,
+  object,
+  optional,
+  record,
+  string,
+  union,
+} from '@/schema'
+import { generateTypes } from '@/typegen'
+
+const fixedGeneratedAt = '2000-01-01T00:00:00.000Z'
+
+const autogeneratedBanner = `/**\n * This file is autogenerated. Do not edit it.\n *\n * Generated at: ${fixedGeneratedAt}\n */\n\n`
+
+describe('typegen', () => {
+  it('emits primitives and special scalars', () => {
+    expect(generateTypes(number())).toBe('number')
+    expect(generateTypes(string())).toBe('string')
+    expect(generateTypes(boolean())).toBe('boolean')
+    expect(generateTypes(nullable())).toBe('null')
+    expect(generateTypes(notDefined())).toBe('undefined')
+    expect(generateTypes(any())).toBe('any')
+  })
+
+  it('emits arrays with parentheses when the item is a union or intersection', () => {
+    expect(generateTypes(array(number()))).toBe('number[]')
+    expect(generateTypes(array(union([number(), string()])))).toBe('(number | string)[]')
+    expect(generateTypes(array(intersection([object({ a: number() }), object({ b: string() })])))).toBe(
+      '({\n  a: number;\n} & {\n  b: string;\n})[]',
+    )
+  })
+
+  it('emits records and objects', () => {
+    expect(generateTypes(record(string(), number()))).toBe('Record<string, number>')
+    expect(
+      generateTypes(
+        object({
+          id: number(),
+          name: string(),
+        }),
+      ),
+    ).toBe('{\n  id: number;\n  name: string;\n}')
+    expect(generateTypes(object({}))).toBe('{}')
+  })
+
+  it('indents nested object properties', () => {
+    const car = object({
+      make: string(),
+      model: string(),
+      year: number(),
+      test: object({ test: string() }),
+    })
+    expect(generateTypes(car)).toBe(
+      '{\n  make: string;\n  model: string;\n  year: number;\n  test: {\n    test: string;\n  };\n}',
+    )
+  })
+
+  it('extracts typeName into a single export and references by name', () => {
+    const user = object(
+      {
+        id: number(),
+        name: string(),
+      },
+      { typeName: 'User' },
+    )
+    expect(generateTypes(user, { generatedAt: fixedGeneratedAt })).toBe(
+      `${autogeneratedBanner}export type User = {\n  id: number;\n  name: string;\n}`,
+    )
+  })
+
+  it('does not duplicate named types when the same name appears multiple times', () => {
+    const user = object({ id: number() }, { typeName: 'User' })
+    const doc = object(
+      {
+        author: user,
+        editor: user,
+      },
+      { typeName: 'Document' },
+    )
+    const out = generateTypes(doc, { generatedAt: fixedGeneratedAt })
+    expect(out.match(/export type User/g)?.length).toBe(1)
+    expect(out).toContain('author: User')
+    expect(out).toContain('editor: User')
+    expect(out).toContain('export type Document =')
+  })
+
+  it('includes typeComment as JSDoc on named exports', () => {
+    const t = object({}, { typeName: 'Empty', typeComment: 'No fields.' })
+    expect(generateTypes(t, { generatedAt: fixedGeneratedAt })).toBe(
+      `${autogeneratedBanner}/** No fields. */\nexport type Empty = {}`,
+    )
+  })
+
+  it('formats multi-line typeComment as a JSDoc block', () => {
+    const t = object({}, { typeName: 'T', typeComment: 'Line 1\nLine 2' })
+    expect(generateTypes(t, { generatedAt: fixedGeneratedAt })).toBe(
+      `${autogeneratedBanner}/** \n * Line 1\n * Line 2\n */\nexport type T = {}`,
+    )
+  })
+
+  it('prefixes file-style output with an autogenerated banner and timestamp', () => {
+    const t = object({ x: number() }, { typeName: 'T' })
+    const out = generateTypes(t, { generatedAt: fixedGeneratedAt })
+    expect(out.startsWith(autogeneratedBanner)).toBe(true)
+    expect(out).toContain('Generated at: 2000-01-01T00:00:00.000Z')
+  })
+
+  it('wraps named types in export namespace when namespace option is set', () => {
+    const user = object(
+      {
+        id: number(),
+        name: string(),
+      },
+      { typeName: 'User' },
+    )
+    expect(generateTypes(user, { generatedAt: fixedGeneratedAt, namespace: 'Models' })).toBe(
+      `${autogeneratedBanner}export namespace Models {\n  export type User = {\n    id: number;\n    name: string;\n  }\n}\n`,
+    )
+  })
+
+  it('keeps cross-references unqualified inside a namespace', () => {
+    const user = object({ id: number() }, { typeName: 'User' })
+    const doc = object({ author: user }, { typeName: 'Document' })
+    const out = generateTypes(doc, { generatedAt: fixedGeneratedAt, namespace: 'Api' })
+    expect(out).toContain('export namespace Api {')
+    expect(out).toContain('author: User')
+    expect(out.match(/export type User/g)?.length).toBe(1)
+  })
+
+  it('ignores namespace when it is not a valid TypeScript identifier', () => {
+    const t = object({ x: number() }, { typeName: 'T' })
+    const out = generateTypes(t, { generatedAt: fixedGeneratedAt, namespace: 'not-valid' })
+    expect(out).not.toContain('export namespace')
+    expect(out).toContain('export type T =')
+  })
+
+  it('includes typeComment as JSDoc on object properties', () => {
+    const t = object({
+      id: number({ typeComment: 'Unique id.' }),
+      name: string({ typeComment: 'Display name.' }),
+    })
+    expect(generateTypes(t)).toBe('{\n  /** Unique id. */\n  id: number;\n  /** Display name. */\n  name: string;\n}')
+  })
+
+  it('indents multi-line property typeComment in nested objects', () => {
+    const t = object({
+      outer: string({ typeComment: 'A\nB' }),
+      inner: object({
+        x: number({ typeComment: 'Nested.' }),
+      }),
+    })
+    expect(generateTypes(t)).toBe(
+      '{\n  /** \n   * A\n   * B\n   */\n  outer: string;\n  inner: {\n    /** Nested. */\n    x: number;\n  };\n}',
+    )
+  })
+
+  it('ignores invalid typeName and keeps inline shape', () => {
+    const bad = object({ x: number() }, { typeName: 'not-valid' })
+    expect(generateTypes(bad)).toBe('{\n  x: number;\n}')
+  })
+
+  it('quotes object keys that are not valid identifiers', () => {
+    expect(generateTypes(object({ 'foo-bar': string() }))).toBe('{\n  "foo-bar": string;\n}')
+  })
+
+  it('emits unions and optionals', () => {
+    expect(generateTypes(union([literal(1), literal(2)]))).toBe('1 | 2')
+    expect(generateTypes(optional(number()))).toBe('number | undefined')
+  })
+
+  it('emits never for an empty union and unknown for an empty intersection', () => {
+    expect(generateTypes(union([]))).toBe('never')
+    expect(generateTypes(intersection([]))).toBe('unknown')
+  })
+
+  it('emits optional object properties with ? instead of | undefined', () => {
+    expect(
+      generateTypes(
+        object({
+          id: number(),
+          name: optional(string()),
+        }),
+      ),
+    ).toBe('{\n  id: number;\n  name?: string;\n}')
+  })
+
+  it('emits literal bigint', () => {
+    expect(generateTypes(literal(10n))).toBe('10n')
+  })
+
+  it('unwraps evaluate to the inner schema type', () => {
+    expect(generateTypes(evaluate((v) => v, number()))).toBe('number')
+  })
+
+  it('resolves lazy schemas', () => {
+    const schema = lazy(() => object({ n: number() }))
+    expect(generateTypes(schema)).toBe('{\n  n: number;\n}')
+  })
+
+  it('returns any when max depth is exhausted', () => {
+    expect(generateTypes(number(), { maxDepth: 0 })).toBe('any')
+  })
+})

package/src/typegen.ts

@@ -0,0 +1,268 @@
+import type { Schema } from './schema'
+
+const DEFAULT_MAX_DEPTH = 10
+
+export type GenerateTypesOptions = {
+  maxDepth?: number
+  /**
+   * ISO 8601 timestamp printed in the autogenerated file banner.
+   * Defaults to the time of the `generateTypes` call when the banner is emitted.
+   */
+  generatedAt?: string
+  /**
+   * When set to a valid TypeScript identifier, wraps all emitted `export type` declarations (and any
+   * trailing root type) in `export namespace Name { ... }` so consumers reference `Name.SomeType`.
+   */
+  namespace?: string
+}
+
+type NamedDeclaration = {
+  name: string
+  body: string
+  comment?: string
+}
+
+type TypeGenContext = {
+  definitions: Map<string, string>
+  declarations: NamedDeclaration[]
+  inProgress: Set<string>
+}
+
+/**
+ * Returns TypeScript for the schema: named `typeName` nodes become `export type` aliases (once each),
+ * referenced by name elsewhere. With no named nodes, returns a single inline type expression (same as before).
+ *
+ * When at least one named type is emitted, the result is prefixed with a banner stating the output is
+ * autogenerated and must not be edited manually, plus a generation timestamp.
+ *
+ * Pass `namespace` to wrap declarations in `export namespace … { … }`.
+ */
+export const generateTypes = (schema: Schema, options?: GenerateTypesOptions): string => {
+  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH
+  const ctx: TypeGenContext = {
+    definitions: new Map(),
+    declarations: [],
+    inProgress: new Set(),
+  }
+  const root = emitSchema(schema, maxDepth, ctx, '')
+
+  if (ctx.declarations.length === 0) {
+    return root
+  }
+
+  const declStrings = ctx.declarations.map(formatNamedDeclaration)
+  const body = declStrings.join('\n\n')
+  const lastDeclared = ctx.declarations.at(-1)?.name
+  let content = lastDeclared === root ? body : `${body}\n\n${root}`
+  const ns = options?.namespace
+  if (ns && isValidTypeScriptIdentifier(ns)) {
+    content = wrapDeclarationsInNamespace(ns, content)
+  }
+  const generatedAt = options?.generatedAt ?? new Date().toISOString()
+  return `${formatAutogeneratedFileBanner(generatedAt)}${content}`
+}
+
+const formatAutogeneratedFileBanner = (generatedAt: string): string =>
+  `/**\n * This file is autogenerated. Do not edit it.\n *\n * Generated at: ${generatedAt}\n */\n\n`
+
+const wrapDeclarationsInNamespace = (namespace: string, content: string): string => {
+  const body = content
+    .split('\n')
+    .map((line) => (line === '' ? '' : `  ${line}`))
+    .join('\n')
+  return `export namespace ${namespace} {\n${body}\n}\n`
+}
+
+const formatNamedDeclaration = (d: NamedDeclaration): string => {
+  const commentBlock = d.comment ? formatTypeCommentAsJsDoc(d.comment) : ''
+  const comment = commentBlock ? `${commentBlock}\n` : ''
+  return `${comment}export type ${d.name} = ${d.body}`
+}
+
+/** Inline JSDoc for one line; multi-line comments use a newline after the opening delimiter and ` * ` on each line. */
+const formatTypeCommentAsJsDoc = (comment: string): string => {
+  const lines = comment.split(/\r?\n/)
+  const trimmed = lines.map((line) => line.trim())
+  while (trimmed.length > 0 && trimmed[0] === '') {
+    trimmed.shift()
+  }
+  while (trimmed.length > 0 && trimmed.at(-1) === '') {
+    trimmed.pop()
+  }
+  if (trimmed.length === 0) {
+    return ''
+  }
+  if (trimmed.length === 1) {
+    return `/** ${trimmed[0]} */`
+  }
+  const body = trimmed.map((line) => ` * ${line}`).join('\n')
+  return `/** \n${body}\n */`
+}
+
+/** Prefixes each line of a JSDoc block with `indent` for object property comments. */
+const formatTypeCommentAsIndentedJsDoc = (indent: string, comment: string): string => {
+  const doc = formatTypeCommentAsJsDoc(comment)
+  if (!doc) {
+    return ''
+  }
+  return doc
+    .split('\n')
+    .map((line) => `${indent}${line}`)
+    .join('\n')
+}
+
+const getTypeName = (schema: Schema): string | undefined => {
+  if (schema.type === 'lazy' || schema.type === 'evaluate') {
+    return undefined
+  }
+  const name = schema.typeName
+  if (!name || !isValidTypeScriptIdentifier(name)) {
+    return undefined
+  }
+  return name
+}
+
+const getTypeComment = (schema: Schema): string | undefined => {
+  if (schema.type === 'lazy' || schema.type === 'evaluate') {
+    return undefined
+  }
+  if (schema.type === 'optional') {
+    return schema.typeComment ?? getTypeComment(schema.schema)
+  }
+  return schema.typeComment
+}
+
+const isValidTypeScriptIdentifier = (name: string): boolean => /^[$_A-Za-z][$_\w]*$/.test(name)
+
+const emitSchema = (schema: Schema, depth: number, ctx: TypeGenContext, braceIndent: string): string => {
+  const name = getTypeName(schema)
+  if (name) {
+    if (ctx.definitions.has(name)) {
+      return name
+    }
+    if (ctx.inProgress.has(name)) {
+      return name
+    }
+    ctx.inProgress.add(name)
+    const body = structuralEmit(schema, depth, ctx, '')
+    ctx.inProgress.delete(name)
+    if (!ctx.definitions.has(name)) {
+      ctx.definitions.set(name, body)
+      ctx.declarations.push({
+        name,
+        body,
+        comment: getTypeComment(schema),
+      })
+    }
+    return name
+  }
+  return structuralEmit(schema, depth, ctx, braceIndent)
+}
+
+const structuralEmit = (schema: Schema, depth: number, ctx: TypeGenContext, braceIndent: string): string => {
+  if (depth <= 0) {
+    return 'any'
+  }
+  const next = depth - 1
+
+  switch (schema.type) {
+    case 'number':
+      return 'number'
+    case 'string':
+      return 'string'
+    case 'boolean':
+      return 'boolean'
+    case 'nullable':
+      return 'null'
+    case 'notDefined':
+      return 'undefined'
+    case 'any':
+      return 'any'
+    case 'array': {
+      const item = emitSchema(schema.items, next, ctx, braceIndent)
+      return needsArrayItemParen(item) ? `(${item})[]` : `${item}[]`
+    }
+    case 'record': {
+      const key = emitSchema(schema.key, next, ctx, braceIndent)
+      const value = emitSchema(schema.value, next, ctx, braceIndent)
+      return `Record<${key}, ${value}>`
+    }
+    case 'object': {
+      const entries = Object.entries(schema.properties)
+      if (entries.length === 0) {
+        return '{}'
+      }
+      const keyIndent = `${braceIndent}  `
+      const props = entries.map(([key, child]) => {
+        const tsKey = /^[$_a-zA-Z][$_\w]*$/.test(key) ? key : JSON.stringify(key)
+        const optionalProp = child.type === 'optional'
+        const valueSchema = optionalProp ? child.schema : child
+        const value = emitSchema(valueSchema, next, ctx, keyIndent)
+        const propComment = getTypeComment(child)
+        const docBlock = propComment ? formatTypeCommentAsIndentedJsDoc(keyIndent, propComment) : ''
+        const propLine = optionalProp ? `${keyIndent}${tsKey}?: ${value};` : `${keyIndent}${tsKey}: ${value};`
+        return docBlock ? `${docBlock}\n${propLine}` : propLine
+      })
+      return `{\n${props.join('\n')}\n${braceIndent}}`
+    }
+    case 'optional': {
+      const inner = emitSchema(schema.schema, next, ctx, braceIndent)
+      return `${wrapUnionMember(inner)} | undefined`
+    }
+    case 'union':
+      if (schema.schemas.length === 0) {
+        return 'never'
+      }
+      return schema.schemas.map((s) => wrapUnionMember(emitSchema(s, next, ctx, braceIndent))).join(' | ')
+    case 'intersection':
+      if (schema.schemas.length === 0) {
+        return 'unknown'
+      }
+      return schema.schemas.map((s) => wrapIntersectionMember(emitSchema(s, next, ctx, braceIndent))).join(' & ')
+    case 'literal':
+      return literalToTs(schema.value)
+    case 'lazy':
+      return emitSchema(schema.schema(), next, ctx, braceIndent)
+    case 'evaluate':
+      return emitSchema(schema.schema, next, ctx, braceIndent)
+    default: {
+      const _exhaustive: never = schema
+      return _exhaustive
+    }
+  }
+}
+
+const literalToTs = (value: string | number | boolean | bigint): string => {
+  if (typeof value === 'bigint') {
+    return `${value}n`
+  }
+  return JSON.stringify(value)
+}
+
+const needsArrayItemParen = (t: string): boolean => {
+  if (t === 'number' || t === 'string' || t === 'boolean' || t === 'null' || t === 'undefined' || t === 'any') {
+    return false
+  }
+  // Union: `A | B[]` is `A | (B[])`; intersection: `A & B[]` is `A & (B[])`. Wrap the whole item type.
+  return t.includes(' | ') || t.includes(' & ')
+}
+
+const wrapUnionMember = (t: string): string => {
+  if (t === 'number' || t === 'string' || t === 'boolean' || t === 'null' || t === 'undefined' || t === 'any') {
+    return t
+  }
+  if (/^(?:-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?|-?\d+n|"(?:[^"\\]|\\.)*"|true|false)$/.test(t)) {
+    return t
+  }
+  if (/^[$_A-Za-z][$_\w]*$/.test(t)) {
+    return t
+  }
+  return `(${t})`
+}
+
+const wrapIntersectionMember = (t: string): string => {
+  if (t.includes(' | ') || t.includes(' & ')) {
+    return `(${t})`
+  }
+  return t
+}