@soundscript/soundscript 0.1.1 → 0.1.3

package/soundscript/json.sts

@@ -2,6 +2,22 @@ import type { Decoder } from '@soundscript/soundscript/decode';
 import type { Encoder } from '@soundscript/soundscript/encode';
 import { Failure } from '@soundscript/soundscript/failures';
 import { isErr, type Result, resultOf } from '@soundscript/soundscript/result';
+import {
+  F32,
+  F64,
+  format as formatNumeric,
+  I8,
+  I16,
+  I32,
+  I64,
+  isNumeric,
+  toHostNumber,
+  type Numeric,
+  U8,
+  U16,
+  U32,
+  U64,
+} from './numerics.js';
 
 export type JsonArray = JsonValue[];
 export type JsonObject = {
@@ -35,8 +51,26 @@ export type JsonLikeValue =
   | JsonLikeObject
   | JsonLikeArray;
 
+export type MachineJsonArray = MachineJsonLikeValue[];
+export type MachineJsonObject = {
+  [key: string]: MachineJsonLikeValue;
+};
+export type MachineJsonLikeValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | null
+  | undefined
+  | Numeric
+  | MachineJsonObject
+  | MachineJsonArray;
+
+export type MachineJsonNumericMode = 'tagged' | 'decimal-string' | 'json-number';
+
 export interface JsonParseOptions {
   int64?: 'default' | 'lossless';
+  numerics?: 'tagged';
 }
 
 export type JsonStringifyBigintMode = 'number' | 'reject' | 'string';
@@ -44,6 +78,7 @@ export type JsonStringifyBigintMode = 'number' | 'reject' | 'string';
 export interface JsonStringifyOptions {
   int64?: 'default' | 'string' | 'lossless';
   readonly bigint?: JsonStringifyBigintMode;
+  numerics?: MachineJsonNumericMode;
 }
 
 const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
@@ -66,12 +101,21 @@ export function parseJson(
   text: string,
   options: JsonParseOptions & { int64: 'lossless' },
 ): Result<LosslessJsonValue, JsonParseFailure>;
+export function parseJson(
+  text: string,
+  options: JsonParseOptions & { numerics: 'tagged' },
+): Result<MachineJsonLikeValue, JsonParseFailure>;
 export function parseJson(
   text: string,
   options: JsonParseOptions = {},
-): Result<JsonValue | LosslessJsonValue, JsonParseFailure> {
+): Result<JsonValue | LosslessJsonValue | MachineJsonLikeValue, JsonParseFailure> {
   return resultOf(
-    () => options.int64 === 'lossless' ? parseLosslessJson(text) : JSON.parse(text),
+    () => {
+      const parsed = options.int64 === 'lossless' ? parseLosslessJson(text) : JSON.parse(text);
+      return options.numerics === 'tagged'
+        ? decodeTaggedMachineJsonValue(parsed as JsonValue | LosslessJsonValue)
+        : parsed;
+    },
     (cause) => new JsonParseFailure(cause),
   );
 }
@@ -82,11 +126,34 @@ export function stringifyJson(
   options: JsonStringifyOptions & { int64: 'string' | 'lossless' },
 ): Result<string, JsonStringifyFailure>;
 export function stringifyJson(
-  value: JsonValue | LosslessJsonValue,
+  value: MachineJsonLikeValue,
+  options: JsonStringifyOptions & { numerics: MachineJsonNumericMode },
+): Result<string, JsonStringifyFailure>;
+export function stringifyJson(
+  value: JsonValue | LosslessJsonValue | MachineJsonLikeValue,
   options: JsonStringifyOptions = {},
 ): Result<string, JsonStringifyFailure> {
   return resultOf(
     () => {
+      if (options.numerics) {
+        const normalized = normalizeMachineJsonLikeValue(
+          value as MachineJsonLikeValue,
+          new Set<object>(),
+          options.numerics,
+          'root',
+        );
+        const encoded = stringifyJsonLikeInternal(
+          normalized,
+          new Set<object>(),
+          options.bigint ?? 'reject',
+          'root',
+        );
+        if (encoded === undefined) {
+          throw new TypeError('JSON stringification produced no top-level value.');
+        }
+        return encoded;
+      }
+
       if (options.int64 === 'string') {
         return stringifyJsonWithInt64Mode(value as LosslessJsonValue, 'string');
       }
@@ -322,6 +389,145 @@ function isJsonLikeValueInternal(
   }
 }
 
+function normalizeMachineJsonLikeValue(
+  value: MachineJsonLikeValue,
+  visited: Set<object>,
+  numericMode: MachineJsonNumericMode,
+  position: 'array' | 'object' | 'root',
+): JsonLikeValue {
+  if (isNumeric(value)) {
+    return normalizeMachineNumericJsonValue(value, numericMode);
+  }
+
+  switch (typeof value) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+    case 'bigint':
+      return value;
+    case 'undefined':
+      return position === 'array' ? null : undefined;
+    case 'object':
+      if (value === null) {
+        return null;
+      }
+
+      if (visited.has(value)) {
+        throw new TypeError('Converting circular structure to machine JSON text.');
+      }
+
+      visited.add(value);
+      try {
+        if (Array.isArray(value)) {
+          return value.map((entry) =>
+            normalizeMachineJsonLikeValue(entry, visited, numericMode, 'array') ?? null
+          );
+        }
+
+        const result: Record<string, JsonLikeValue> = {};
+        for (const key of Object.keys(value)) {
+          const normalized = normalizeMachineJsonLikeValue(
+            (value as MachineJsonObject)[key]!,
+            visited,
+            numericMode,
+            'object',
+          );
+          if (normalized !== undefined) {
+            result[key] = normalized;
+          }
+        }
+        return result;
+      } finally {
+        visited.delete(value);
+      }
+    default:
+      throw new TypeError(`Unsupported machine JSON value kind: ${typeof value}`);
+  }
+}
+
+function normalizeMachineNumericJsonValue(
+  value: Numeric,
+  numericMode: MachineJsonNumericMode,
+): JsonLikeValue {
+  switch (numericMode) {
+    case 'tagged':
+      return value.toJSON();
+    case 'decimal-string':
+      return formatNumeric(value);
+    case 'json-number':
+      switch (value.__soundscript_numeric_kind) {
+        case 'i64':
+        case 'u64':
+          throw new TypeError('json-number machine JSON mode does not support bigint-backed machine numerics.');
+        default:
+          return toHostNumber(value);
+      }
+  }
+}
+
+function decodeTaggedMachineJsonValue(value: JsonValue | LosslessJsonValue): MachineJsonLikeValue {
+  if (Array.isArray(value)) {
+    return value.map((entry) => decodeTaggedMachineJsonValue(entry));
+  }
+
+  if (value && typeof value === 'object') {
+    const taggedNumeric = decodeTaggedMachineNumeric(value);
+    if (taggedNumeric) {
+      return taggedNumeric;
+    }
+
+    const result: Record<string, MachineJsonLikeValue> = {};
+    for (const key of Object.keys(value)) {
+      result[key] = decodeTaggedMachineJsonValue(value[key]!);
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function decodeTaggedMachineNumeric(
+  value: Record<string, JsonValue | LosslessJsonValue>,
+): Numeric | undefined {
+  const numericKind = value.$numeric;
+  const numericValue = value.value;
+  const keys = Object.keys(value);
+  if (
+    typeof numericKind !== 'string' ||
+    typeof numericValue !== 'string' ||
+    keys.length !== 2 ||
+    !keys.includes('$numeric') ||
+    !keys.includes('value')
+  ) {
+    return undefined;
+  }
+
+  switch (numericKind) {
+    case 'f64':
+      return F64.parse(numericValue);
+    case 'f32':
+      return F32.parse(numericValue);
+    case 'i8':
+      return I8.parse(numericValue);
+    case 'i16':
+      return I16.parse(numericValue);
+    case 'i32':
+      return I32.parse(numericValue);
+    case 'i64':
+      return I64.parse(numericValue);
+    case 'u8':
+      return U8.parse(numericValue);
+    case 'u16':
+      return U16.parse(numericValue);
+    case 'u32':
+      return U32.parse(numericValue);
+    case 'u64':
+      return U64.parse(numericValue);
+    default:
+      return undefined;
+  }
+}
+
 function stringifyJsonLikeInternal(
   value: JsonLikeValue,
   visited: Set<object>,