Implement formatShallow for all primitive representations

Author: novemberborn

src/accessors/element.ts

@@ -16,6 +16,7 @@ import type {
   ValueRepresentation,
 } from '../value.js'
 import { UndefinedRepresentation } from '../values/primitives/undefined.ts'
+import type { Formatter } from '../formatter.ts'
 
 export class SparseValueRepresentation implements CommonRepresentation, ShallowFunctionality {
   readonly #sparse: undefined
@@ -27,6 +28,10 @@ export class SparseValueRepresentation implements CommonRepresentation, ShallowF
     return unequal
   }
 
+  formatShallow(formatter: Formatter): void {
+    formatter.append(formatter.theme.array.sparse)
+  }
+
   serializeShallow(encoder: Encoder): ShallowSerializationResult {
     encoder.staticType(staticTypeTable.undefined)
     return finished

src/accessors/test/element.ts

@@ -6,6 +6,8 @@ import { Encoder } from '../../encoder.ts'
 import { strictlyEqual, unequal, deeplyEqual } from '../../comparison.ts'
 import { partial, finished } from '../../serialization-result.ts'
 import { staticTypeTable } from '../../serialization-types.ts'
+import { deriveTheme } from '../../theme.ts'
+import { Formatter } from '../../formatter.ts'
 
 // SparseValueRepresentation Tests
 test('SparseValueRepresentation - compare returns strictlyEqual for other sparse values', (t) => {
@@ -29,6 +31,15 @@ test('SparseValueRepresentation - compare returns unequal for other values', (t)
   t.is(sparse.compare(str), unequal)
 })
 
+test('SparseValueRepresentation - formatShallow formats as sparse', (t) => {
+  const sparse = new SparseValueRepresentation()
+  const theme = deriveTheme()
+  const formatter = new Formatter(theme)
+  sparse.formatShallow(formatter)
+  const rendered = formatter.close().render()
+  t.is(rendered, theme.array.sparse)
+})
+
 test('SparseValueRepresentation - serializeShallow encodes as undefined', (t) => {
   const sparse = new SparseValueRepresentation()
 

src/accessors/test/property.ts

@@ -74,6 +74,7 @@ test('NamedPropertyAccessor - serialize encodes key as string and delegates to v
   // Create a mock value with serializeShallow
   const mockValue = {
     compare: (): Comparison => strictlyEqual,
+    formatShallow: () => {},
     serializeShallow: (encoder: Encoder): typeof finished => {
       encoder.uint8Array(new Uint8Array([42]))
       return finished

src/theme.ts

@@ -96,6 +96,7 @@ export function normalizeTheme<T extends ThemeRecord>(root: T): NormalizedTheme<
 const defaultTheme = normalizeTheme({
   array: {
     bracket: { open: '[', close: ']' },
+    sparse: '«empty item»',
   },
   aspect: { separator: '---' },
   bigInt: { open: '', close: '' },
@@ -119,6 +120,7 @@ const defaultTheme = normalizeTheme({
     constructor: { open: '(', close: ')' },
     name: { open: '', close: '' },
   },
+  external: '«external»',
   function: {
     name: { open: '', close: '' },
     stringTag: { open: '', close: '' },
@@ -133,10 +135,10 @@ const defaultTheme = normalizeTheme({
   number: { open: '', close: '' },
   object: {
     bracket: { open: '{', close: '}' },
-    constructorName: { open: '', close: '', empty: '\u00ABempty constructor name\u00BB' },
-    nullPrototype: '\u00ABnull prototype\u00BB',
-    stringTag: { open: '@', close: '', empty: '\u00ABempty string tag\u00BB' },
-    secondaryStringTag: { open: '@', close: '', empty: '\u00ABempty string tag\u00BB' },
+    constructorName: { open: '', close: '', empty: '«empty constructor name»' },
+    nullPrototype: '«null prototype»',
+    stringTag: { open: '@', close: '', empty: '«empty string tag»' },
+    secondaryStringTag: { open: '@', close: '', empty: '«empty string tag»' },
   },
   property: {
     after: ',',

src/value.d.ts

@@ -1,6 +1,7 @@
 import type { SymbolPropertyAccessor } from './accessors/property.ts'
 import type { Comparison } from './comparison.ts'
 import type { Encoder } from './encoder.ts'
+import type { Formatter } from './formatter.ts'
 import type { ShallowSerializationResult, SerializationResult } from './serialization-result.ts'
 
 export type CommonRepresentation = {
@@ -11,6 +12,7 @@ export type CommonRepresentation = {
 }
 
 export type ShallowFunctionality = {
+  formatShallow(formatter: Formatter): void
   serializeShallow(encoder: Encoder): ShallowSerializationResult
 }
 

src/values/nodejs/external.ts

@@ -7,6 +7,7 @@ import { staticTypeTable } from '../../serialization-types.ts'
 import { type ShallowSerializationResult, finished } from '../../serialization-result.ts'
 import type { Decoder } from '../../decoder.ts'
 import type { DeserializationContext } from '../../deserialization-context.ts'
+import type { Formatter } from '../../formatter.ts'
 
 export class ExternalRepresentation implements CommonRepresentation, ShallowFunctionality {
   static deserialize(context: DeserializationContext, decoder: Decoder): ExternalRepresentation {
@@ -36,6 +37,10 @@ export class ExternalRepresentation implements CommonRepresentation, ShallowFunc
     return this.#value === other.#value ? strictlyEqual : unequal
   }
 
+  formatShallow(formatter: Formatter): void {
+    formatter.append(formatter.theme.external)
+  }
+
   serializeShallow(encoder: Encoder): ShallowSerializationResult {
     encoder.staticType(staticTypeTable.external).annotations({
       p: this.pointer,

src/values/nodejs/test/external.ts

@@ -8,6 +8,8 @@ import { possiblyEqual, strictlyEqual, unequal } from '../../../comparison.ts'
 import { staticTypeTable } from '../../../serialization-types.ts'
 import { snapshotEncoded } from '../../test/helpers/snapshot-encoded.ts'
 import { finished } from '../../../serialization-result.ts'
+import { deriveTheme } from '../../../theme.ts'
+import { Formatter } from '../../../formatter.ts'
 
 // @ts-expect-error ts2307: Suppress error about missing import
 const refNapi = await (import('ref-napi') as Promise<{ default: { instance: object } }>)
@@ -95,6 +97,19 @@ test('compare returns possiblyEqual when either context is deserialized', (t) =>
   )
 })
 
+// Formatting tests
+test('formatShallow applies the correct theme for external values', (t) => {
+  const context = new DescriptionContext()
+  const externalRep = context.represent(externalValue) as ExternalRepresentation
+
+  const formatter = new Formatter(deriveTheme())
+  externalRep.formatShallow(formatter)
+  const rendered = formatter.close().render()
+
+  // Check if the theme was applied correctly
+  t.is(rendered, formatter.theme.external)
+})
+
 // Serialization tests
 test('serializeShallow uses the external static type', (t) => {
   const context = new DescriptionContext()